def test_setClient(self):
c1 = Client(ip="1.2.3.4", connections=2, guid="abcdefghijkl", pbid="123546abcdef", name="some dude",
greeting="hi!", mask_level=20, group_bits=8, login="******", password="******")
c1_id = self.storage.setClient(c1)
self.assertEqual(1, c1_id)
c2 = self.storage.getClient(Client(id=c1_id))
self.assertIsInstance(c2, Client)
self.assertEqual("1.2.3.4", c2.ip)
self.assertEqual(2, c2.connections)
self.assertEqual("abcdefghijkl", c2.guid)
self.assertEqual("123546abcdef", c2.pbid)
self.assertEqual("some dude", c2.name)
self.assertEqual("hi!", c2.greeting)
self.assertEqual("test login", c2.login)
self.assertEqual("test password", c2.password)
c3 = Client(id=c1_id, ip="5.6.7.8", connections=1, guid="ddddddddd", pbid="zzzzzzzzzzz", name="milka",
greeting="hello")
self.storage.setClient(c3)
c4 = self.storage.getClient(Client(id=c1_id))
self.assertIsInstance(c4, Client)
self.assertEqual("5.6.7.8", c4.ip)
self.assertEqual(1, c4.connections)
self.assertEqual("ddddddddd", c4.guid)
self.assertEqual("zzzzzzzzzzz", c4.pbid)
self.assertEqual("milka", c4.name)
self.assertEqual("hello", c4.greeting)
def test_getClientsMatching(self):
self.storage.setClient(Client(ip="1.2.3.4", connections=2, guid="mlkjmlkjqsdf", pbid="123546abcdef", name="bill"))
self.storage.setClient(Client(ip="4.2.3.5", connections=3, guid="azerazerazer", pbid="wxcvwxvcxwcv", name="john"))
self.storage.setClient(Client(ip="4.2.3.5", connections=45, guid="rtyrtyrty", pbid="rtyrtyrrtyr", name="jack"))
result = self.storage.getClientsMatching({'guid': "xxxxxxxxxx"})
self.assertEqual(0, len(result))
result = self.storage.getClientsMatching({'ip': "1.2.3.4"})
self.assertEqual(1, len(result))
self.assertEqual('bill', result[0].name)
result = self.storage.getClientsMatching({'ip': "4.2.3.5"})
self.assertEqual(2, len(result))
result = self.storage.getClientsMatching({'pbid': "rtyrtyrrtyr"})
self.assertEqual(1, len(result))
self.assertEqual('jack', result[0].name)
result = self.storage.getClientsMatching({'name': "jack"})
self.assertEqual(1, len(result))
self.assertEqual('jack', result[0].name)
result = self.storage.getClientsMatching({'ip': "4.2.3.5", 'name': 'jack'})
self.assertEqual(1, len(result))
self.assertEqual('jack', result[0].name)
result = self.storage.getClientsMatching({'ip': "4.2.3.5", 'connections >': 10})
self.assertEqual(1, len(result))
self.assertEqual('jack', result[0].name)
def test_getClient_guid(self):
c1 = Client(ip="1.2.3.4", connections=3, guid="mlkjmlkjqsdf", pbid="123546abcdef", name="some dude", greeting="hi!")
c1_id = self.storage.setClient(c1)
self.assertEqual(1, c1_id)
c2 = self.storage.getClient(Client(guid="mlkjmlkjqsdf"))
self.assertIsInstance(c2, Client)
self.assertRaises(KeyError, self.storage.getClient, Client(guid='god'))
def test_two_bans_with_reason(self):
# GIVEN
when(self.console).time().thenReturn(0)
player1 = Client(console=self.console, guid='player1GUID', name="P1")
player1.save()
penalty1 = ClientBan(clientId=player1.id,
timeExpire=-1,
adminId=0,
reason="test reason")
player2 = Client(console=self.console, guid='player2GUID', name="P2")
player2.save()
penalty2 = ClientTempBan(clientId=player2.id,
timeExpire=self.console.time() + 60 * 2,
adminId=0,
reason="test reason f00")
when(self.console.storage).getLastPenalties(types=whatever(),
num=whatever()).thenReturn(
[penalty1, penalty2])
# WHEN
self.lastbans()
# THEN
self.mock_command.sayLoudOrPM.assert_has_calls([
call(self.player, u'^2@1^7 P1^7^7 (Perm) test reason'),
call(self.player,
u'^2@2^7 P2^7^7 (2 minutes remaining) test reason f00'),
])
def test_truncateTables_single_table(self):
self.storage.setClient(Client(guid="aaaaaaaaa"))
self.storage.setClient(Client(guid="bbbbbbbbb"))
cursor = self.storage.query("SELECT * FROM clients")
self.assertFalse(cursor.EOF)
self.storage.truncateTable('clients')
cursor = self.storage.query("SELECT * FROM clients")
self.assertTrue(cursor.EOF)
def setUp(self):
B3TestCase.setUp(self)
self.queueEvent_patcher = patch.object(self.console, 'queueEvent')
self.queueEvent_mock = self.queueEvent_patcher.start()
self.admin = Client(console=self.console)
self.client = Client(console=self.console)
self.client.save()
def test_connected_client_with_verified_guid(self):
# GIVEN
self.parser.routeBattleyeEvent(
u'Player #8 Max (111.222.200.50:2304) connected')
self.parser.routeBattleyeEvent(
u'Player #8 Max - GUID: 73c5e50a7860475f0000000000000000 (unverified)'
)
self.parser.routeBattleyeEvent(
u'Verified GUID (73c5e50a7860475f0000000000000000) of player #8 Max'
)
self.assertDictContainsSubset({'clients': 2},
self.parser.storage.getCounts())
self.assertIn('8', self.parser.clients)
# GIVEN that the player exists in database
client_from_db = self.parser.storage.getClient(
Client(guid="73c5e50a7860475f0000000000000000"))
self.assertIsNotNone(client_from_db)
self.assertEqual("Max", client_from_db.name)
self.assertEqual("73c5e50a7860475f0000000000000000",
client_from_db.guid)
self.assertEqual("111.222.200.50", client_from_db.ip)
self.clear_events()
# WHEN
when(self.parser.output).write('players').thenReturn('''\
Players on server:
[#] [IP Address]:[Port] [Ping] [GUID] [Name]
--------------------------------------------------
8 111.222.200.50:2304 62 73c5e50a7860475f0000000000000000(OK) Max (Lobby)
(1 players in total)
''')
rv = self.parser.sync()
# THEN no new client is saved to database
self.assertDictContainsSubset({'clients': 2},
self.parser.storage.getCounts())
# THEN sync return correct info
self.assertIn('8', rv)
client = rv["8"]
self.assertEqual("Max", client.name)
self.assertEqual("8", client.cid)
self.assertEqual("111.222.200.50", client.ip)
self.assertEqual('73c5e50a7860475f0000000000000000', client.guid)
self.assertTrue(client.authed)
# THEN connected client list is updated
self.assertIn('8', self.parser.clients)
client = self.parser.clients['8']
self.assertEqual("Max", client.name)
self.assertEqual("111.222.200.50", client.ip)
self.assertEqual('73c5e50a7860475f0000000000000000', client.guid)
self.assertTrue(client.authed)
# THEN player info in database is correct
client_from_db = self.parser.storage.getClient(
Client(guid="73c5e50a7860475f0000000000000000"))
self.assertIsNotNone(client_from_db)
self.assertEqual("Max", client_from_db.name)
self.assertEqual("73c5e50a7860475f0000000000000000",
client_from_db.guid)
self.assertEqual("111.222.200.50", client_from_db.ip)
def test_player_connecting_with_unverified_guid_at_first(self):
# GIVEN
self.clear_events()
# WHEN
self.parser.routeBattleyeEvent(u'Player #8 Max (111.222.200.50:2304) connected')
self.parser.routeBattleyeEvent(u'Player #8 Max - GUID: 73c5e50a7860475f0000000000000000 (unverified)')
self.parser.routeBattleyeEvent(u'Verified GUID (73c5e50a7860475f0000000000000000) of player #8 Max')
# THEN
self.assertEqual(2, len(self.evt_queue))
event1, event2 = self.evt_queue
# check EVT_CLIENT_CONNECT
self.assertEqual(self.parser.getEventID("EVT_CLIENT_CONNECT"), event1.type)
self.assertEqual("Max", event1.client.name)
self.assertEqual("8", event1.client.cid)
self.assertEqual("73c5e50a7860475f0000000000000000", event1.client.guid)
self.assertEqual("111.222.200.50", event1.client.ip)
# check EVT_CLIENT_CONNECT
self.assertEqual(self.parser.getEventID("EVT_CLIENT_AUTH"), event2.type)
self.assertEqual("Max", event2.client.name)
self.assertEqual("8", event2.client.cid)
self.assertEqual("73c5e50a7860475f0000000000000000", event2.client.guid)
self.assertEqual("111.222.200.50", event2.client.ip)
# check player info in database
client_from_db = self.parser.storage.getClient(Client(guid="73c5e50a7860475f0000000000000000"))
self.assertIsNotNone(client_from_db)
self.assertEqual("Max", client_from_db.name)
self.assertEqual("73c5e50a7860475f0000000000000000", client_from_db.guid)
self.assertEqual("111.222.200.50", client_from_db.ip)
def setUp(self):
CommandTestCase.setUp(self)
self.init()
self.player = Client(console=self.console, name="joe", _maxLevel=0)
self.player.message = Mock()
self.assertEqual(0, self.player.maskedLevel)
self.assertIsNone(self.player.maskedGroup)
def test_auth_client_without_guid_but_with_known_pbid(self):
# GIVEN
# known superadmin named Snoopy
superadmin = Client(console=self.parser, name='Snoopy', guid='EA_AAAAAAAABBBBBBBBBBBBBB00000000000012222', pbid='300000aaaaaabbbbbbccccc111223300', group_bits=128, connections=21)
superadmin.save()
# bf3 server failing to provide guid
def write(data):
if data == ('admin.listPlayers', 'player', 'Snoopy'):
return ['7', 'name', 'guid', 'teamId', 'squadId', 'kills', 'deaths', 'score', '1', 'Snoopy', '', '2', '8', '0', '0', '0']
else:
return DEFAULT
self.write_mock.side_effect = write
# WHEN
self.assertFalse('Snoopy' in self.parser.clients)
self.parser.OnPBPlayerGuid(match=re.match(self.regex_for_OnPBPlistItem, self.event_raw_data), data=self.event_raw_data)
# THEN
# B3 should have authed Snoopy
self.assertTrue('Snoopy' in self.parser.clients)
snoopy = self.parser.clients['Snoopy']
self.assertTrue(snoopy.authed)
for attb in ('name', 'pbid', 'guid', 'groupBits'):
self.assertEqual(getattr(superadmin, attb), getattr(snoopy, attb))
def test_message_with_color_codes(self):
self.parser.msgPrefix = "[Pre]"
player = Client(console=self.parser, guid="theGuid")
with patch.object(self.parser.output, 'write') as write_mock:
player.message("^7message ^1with ^2color ^8codes")
write_mock.assert_has_calls(
[call('sm_psay #theGuid "[Pre] message with color codes"')])
def test_known_client__guid(self):
# GIVEN
known_client = Client(console=self.parser,
guid="12312312312312312",
name="courgette",
connections=15)
known_client.save()
self.assertEqual(1, len(self.parser.clients))
self.assertDictContainsSubset({'clients': 2},
self.parser.storage.getCounts())
# WHEN
client = self.parser.getClientOrCreate(guid="12312312312312312",
name="newName",
team="0")
# THEN
self.assertIsInstance(client, Client)
self.assertEqual(known_client.id, client.id)
self.assertEqual("12312312312312312", client.cid)
self.assertEqual("12312312312312312", client.guid)
self.assertEqual("newName", client.name)
self.assertEqual(TEAM_SCAVENGERS, client.team)
self.assertEqual(16, client.connections)
self.assertTrue(client.authed)
self.assertEqual(2, len(self.parser.clients))
self.assertDictContainsSubset({'clients': 2},
self.parser.storage.getCounts())
def test_player_connecting_with_unverified_guid_at_first_and_sync(self):
# GIVEN
self.clear_events()
# WHEN
self.parser.routeBattleyeEvent(
u'Player #8 Max (111.222.200.50:2304) connected')
self.parser.routeBattleyeEvent(
u'Player #8 Max - GUID: 73c5e50a7860475f0000000000000000 (unverified)'
)
when(self.parser.output).write('players').thenReturn(
u'''Players on server:
[#] [IP Address]:[Port] [Ping] [GUID] [Name]
--------------------------------------------------
8 111.222.200.50:2304 -1 73c5e50a7860475f0000000000000000(?) Max (Lobby)
(14 players in total)''')
self.parser.sync()
self.parser.routeBattleyeEvent(
u'Verified GUID (73c5e50a7860475f0000000000000000) of player #8 Max'
)
# THEN check events were raised
self.assert_has_event("EVT_CLIENT_CONNECT")
self.assert_has_event("EVT_CLIENT_AUTH")
# check player info in database
client_from_db = self.parser.storage.getClient(
Client(guid="73c5e50a7860475f0000000000000000"))
self.assertIsNotNone(client_from_db)
self.assertEqual("Max", client_from_db.name)
self.assertEqual("73c5e50a7860475f0000000000000000",
client_from_db.guid)
self.assertEqual("111.222.200.50", client_from_db.ip)
def test_truncateTables_multiple_tables(self):
c1 = Client(guid="aaaaaaaaa")
c2 = Client(guid="bbbbbbbbb")
self.storage.setClient(c1)
self.storage.setClient(c2)
self.storage.setClientPenalty(Penalty(clientId=c1.id, adminId=0, type='Kick'))
self.storage.setClientPenalty(Penalty(clientId=c2.id, adminId=0, type='Kick'))
cursor = self.storage.query("SELECT * FROM clients")
self.assertFalse(cursor.EOF)
cursor = self.storage.query("SELECT * FROM penalties")
self.assertFalse(cursor.EOF)
self.storage.truncateTable(['clients', 'penalties'])
cursor = self.storage.query("SELECT * FROM clients")
self.assertTrue(cursor.EOF)
cursor = self.storage.query("SELECT * FROM penalties")
self.assertTrue(cursor.EOF)
def on_kicked(self, name, cid, guid, team, properties):
# L 08/28/2012 - 00:12:07: [basecommands.smx] "Console<0><Console><Console>" kicked "courgette<91><STEAM_1:0:1111111><>" (reason "f00")
client = self.storage.getClient(Client(guid=guid))
if client:
p = self.parseProperties(properties)
return self.getEvent("EVT_CLIENT_KICK", p.get('reason', ''),
client)
def test_message_with_color_codes(self):
self.parser.msgPrefix = "[Pre]"
player = Client(console=self.parser, guid="theGuid")
with patch.object(self.parser, 'writelines') as write_mock:
player.message("^7message ^1with ^2color ^8codes")
write_mock.assert_has_calls(
[call(['m [Pre] ^8[pm]^7 ^7message ^1with ^2color ^8codes'])])
def test_entered_the_game(self):
# GIVEN
p = Client(cid="12312312312312312", guid="12312312312312312", name="courgette")
self.queueEvent_mock.reset_mock()
# WHEN
self.parser.route_game_event('''"courgette<12312312312312312><0>" entered the game''')
# THEN
self.assert_has_event('EVT_CLIENT_JOIN', client=p)
def test_getCounts(self):
c1 = Client(guid="aaaaaaaaa")
self.assertEqual({'Kicks': 0, 'TempBans': 0, 'clients': 0, 'Bans': 0, 'Warnings': 0}, self.storage.getCounts())
self.storage.setClient(c1)
self.assertEqual({'Kicks': 0, 'TempBans': 0, 'clients': 1, 'Bans': 0, 'Warnings': 0}, self.storage.getCounts())
self.storage.setClient(Client(guid="bbbbbbbbbb"))
self.assertEqual({'Kicks': 0, 'TempBans': 0, 'clients': 2, 'Bans': 0, 'Warnings': 0}, self.storage.getCounts())
Penalty(clientId=c1.id, adminId=0, type='Ban').save(self.console)
self.assertEqual({'Kicks': 0, 'TempBans': 0, 'clients': 2, 'Bans': 1, 'Warnings': 0}, self.storage.getCounts())
Penalty(clientId=c1.id, adminId=0, type='Ban').save(self.console)
self.assertEqual({'Kicks': 0, 'TempBans': 0, 'clients': 2, 'Bans': 2, 'Warnings': 0}, self.storage.getCounts())
Penalty(clientId=c1.id, adminId=0, type='TempBan').save(self.console)
self.assertEqual({'Kicks': 0, 'TempBans': 1, 'clients': 2, 'Bans': 2, 'Warnings': 0}, self.storage.getCounts())
Penalty(clientId=c1.id, adminId=0, type='Kick').save(self.console)
self.assertEqual({'Kicks': 1, 'TempBans': 1, 'clients': 2, 'Bans': 2, 'Warnings': 0}, self.storage.getCounts())
Penalty(clientId=c1.id, adminId=0, type='Warning').save(self.console)
self.assertEqual({'Kicks': 1, 'TempBans': 1, 'clients': 2, 'Bans': 2, 'Warnings': 1}, self.storage.getCounts())
def test_message(self):
"""\
display a message to a given player
"""
superman = Client(console=self.console, cid="11")
self.console.msgPrefix = "B3:"
self.console.message(superman, "something")
verify(self.output_mock).write('tell 11 B3: ^3[pm]^7 something')
def test_say(self):
# GIVEN
p = Client(cid="12312312312312312", guid="12312312312312312", name="courgette")
self.queueEvent_mock.reset_mock()
# WHEN
self.parser.route_game_event('''"courgette<12312312312312312><1>" say "<FONT COLOR='#FF0000'> hi"''')
# THEN
self.assert_has_event('EVT_CLIENT_SAY', data="hi", client=p)
def test_say_team(self):
# GIVEN
p = Client(cid="12312312312312312", guid="12312312312312312", name="courgette")
self.queueEvent_mock.reset_mock()
# WHEN
self.parser.route_game_event(r'''"courgette<12312312312312312><1>" say_team "(Team) <FONT COLOR='#66CCFF'> hi team"''')
# THEN
self.assert_has_event('EVT_CLIENT_TEAM_SAY', data="hi team", client=p)
def test_joined_team(self):
# GIVEN
p = Client(cid="12312312312312312", guid="12312312312312312", name="courgette")
self.queueEvent_mock.reset_mock()
# WHEN
self.parser.route_game_event('''"courgette<12312312312312312><1>" joined team "1"''')
# THEN
self.assert_has_event('EVT_CLIENT_TEAM_CHANGE', data=TEAM_RESISTANCE, client=p)
def test_committed_suicide(self):
# GIVEN
p = Client(cid="12312312312312312", guid="12312312312312312", name="courgette")
self.queueEvent_mock.reset_mock()
# WHEN
self.parser.route_game_event('''"courgette<12312312312312312><1>" committed suicide with "R_DmgType_M26Grenade"''')
# THEN
self.assert_has_event('EVT_CLIENT_SUICIDE', data=(100, "R_DmgType_M26Grenade", 'body'), client=p, target=p)
def test_connected(self):
# GIVEN
p = Client(cid="12312312312312312", guid="12312312312312312", ip="192.168.0.1")
self.queueEvent_mock.reset_mock()
# WHEN
self.parser.route_game_event('''"<12312312312312312><>" connected, address "192.168.0.1"''')
# THEN
self.assert_has_event('EVT_CLIENT_CONNECT', data=self.whatever, client=p)
def test_disconnected(self):
# GIVEN
p = Client(cid="12312312312312312", guid="12312312312312312", name="courgette")
self.queueEvent_mock.reset_mock()
# WHEN
self.parser.route_game_event('''"courgette<12312312312312312><0>"disconnected''')
# THEN
self.assert_has_event('EVT_CLIENT_DISCONNECT', data="12312312312312312", client=p)
def test_with_named_parameters__unicode(self):
client = Client(name=u"ÄÖé")
self.assertDictContainsSubset(
{
'clientname': client.name,
'reason': 'this is a good reason'
},
self.parser.getMessageVariables(client=client,
reason="this is a good reason"))
def test_with_named_parameters(self):
client = Client(name="Jack")
self.assertDictIsSubset(
{
'clientname': client.name,
'reason': 'this is a good reason'
},
self.parser.getMessageVariables(client=client,
reason="this is a good reason"))
def on_banid(self, name, cid, guid, team, duration, admin):
# L 08/28/2012 - 00:03:01: Banid: "courgette<91><STEAM_1:0:1111111><>" was banned "for 1.00 minutes" by "Console"
client = self.storage.getClient(Client(guid=guid))
if client:
return self.getEvent("EVT_CLIENT_BAN_TEMP", {
"duration": duration,
"admin": admin,
'reason': None
}, client)
def onServerUnBan(self, name, guid, hash):
"""UnBanned Player: PlayerName="" PlayerID=-1 ProfileID=1561500 Hash="""
# we are using storage instead of self.clients because the player cannot be connected
client = self.storage.getClient(Client(guid=guid))
if client:
self.saybig("%s removed from server banlist" % client.name)
else:
self.error('Cannot find banned client')
# update banlist
self.retrieveBanList()
def onServerBan_remove(self, data):
""" [int: SteamID] """
# we are using storage instead of self.clients because the player
# is obviously not connected when banned
client = self.storage.getClient(Client(guid=data))
if client:
self.write(self.getCommand('saybig', prefix='', message="%s removed from server banlist" % client.name))
else:
self.write(self.getCommand('saybig', prefix='', message="%s unbanned" % data))
# update banlist
self.retrieveBanList()
