class SpamcontrolTestCase(B3TestCase):
""" Ease testcases that need an working B3 console and need to control the Spamcontrol plugin config """
def setUp(self):
self.timer_patcher = patch('threading.Timer')
self.timer_patcher.start()
self.log = logging.getLogger('output')
self.log.propagate = False
B3TestCase.setUp(self)
self.console.startup()
self.log.propagate = True
def tearDown(self):
B3TestCase.tearDown(self)
self.timer_patcher.stop()
def init_plugin(self, config_content):
self.conf = XmlConfigParser()
self.conf.setXml(config_content)
self.p = SpamcontrolPlugin(self.console, self.conf)
self.log.setLevel(logging.DEBUG)
self.log.info("============================= Spamcontrol plugin: loading config ============================")
self.p.onLoadConfig()
self.log.info("============================= Spamcontrol plugin: starting =================================")
self.p.onStartup()
class Test_cmd_serverreboot(Bf3TestCase):
def setUp(self):
super(Test_cmd_serverreboot, self).setUp()
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration plugin="poweradminbf3">
<settings name="commands">
<set name="serverreboot">100</set>
</settings>
</configuration>
""")
self.p = Poweradminbf3Plugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
def test_nominal(self, sleep_mock):
self.console.write.expect(('admin.shutDown',))
self.superadmin.connects("god")
self.superadmin.says("!serverreboot")
self.console.write.verify_expected_calls()
def test_frostbite_error(self, sleep_mock):
self.console.write.expect(('admin.shutDown',)).thenRaise(CommandFailedError(['fOO']))
self.superadmin.connects("god")
self.superadmin.message_history = []
self.superadmin.says("!serverreboot")
self.console.write.verify_expected_calls()
self.assertEqual(['Error: fOO'], self.superadmin.message_history)
def testAdmins():
conf = XmlConfigParser()
conf.setXml("""
<configuration plugin="adv">
<settings name="settings">
<set name="rate">1s</set>
</settings>
<ads>
<ad>^2Do you like B3? Consider donating to the project at www.BigBrotherBot.net</ad>
<ad>@admins</ad>
</ads>
</configuration>
""")
p = AdvPlugin(fakeConsole, conf)
p.onStartup()
p.adv()
print "-----------------------------"
time.sleep(4)
joe.connects(1)
time.sleep(4)
moderator.connects(2)
time.sleep(4)
superadmin.connects(3)
time.sleep(60)
class Test_patch_b3_Client_isAlive(BF3TestCase):
def setUp(self):
BF3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = Bf3Parser(self.conf)
self.foobar = self.parser.clients.newClient(cid='Foobar', name='Foobar', guid="FoobarGuid")
def test_unknown(self):
# GIVEN
when(self.parser).write(('player.isAlive', 'Foobar')).thenReturn()
# THEN
self.assertEqual(b3.STATE_UNKNOWN, self.foobar.state)
def test_alive(self):
# GIVEN
when(self.parser).write(('player.isAlive', 'Foobar')).thenReturn(['true'])
# THEN
self.assertEqual(b3.STATE_ALIVE, self.foobar.state)
def test_dead(self):
# GIVEN
when(self.parser).write(('player.isAlive', 'Foobar')).thenReturn(['false'])
# THEN
self.assertEqual(b3.STATE_DEAD, self.foobar.state)
def test_exception_InvalidPlayerName(self):
when(self.parser).write(('player.isAlive', 'Foobar')).thenRaise(CommandFailedError(['InvalidPlayerName']))
self.assertEqual(b3.STATE_UNKNOWN, self.foobar.state)
class AdminTestCase(unittest.TestCase):
"""
Test case that is suitable for testing Insurgency parser specific features with the B3 admin plugin available
"""
@classmethod
def setUpClass(cls):
from b3.fake import FakeConsole
InsurgencyParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# InsurgencyParser -> FakeConsole -> Parser
def setUp(self):
self.status_response = None # defaults to STATUS_RESPONSE module attribute
self.conf = XmlConfigParser()
self.conf.loadFromString("""<configuration></configuration>""")
self.parser = InsurgencyParser(self.conf)
self.parser.output = Mock()
self.parser.output.write = Mock(wraps=sys.stdout.write)
when(self.parser).is_sourcemod_installed().thenReturn(True)
adminPlugin_conf = CfgConfigParser()
adminPlugin_conf.load(ADMIN_CONFIG_FILE)
adminPlugin = AdminPlugin(self.parser, adminPlugin_conf)
adminPlugin.onLoadConfig()
adminPlugin.onStartup()
when(self.parser).getPlugin('admin').thenReturn(adminPlugin)
when(self.parser).getAllAvailableMaps().thenReturn (['buhriz', 'district', 'sinjar', 'siege', 'uprising', 'ministry', 'revolt', 'heights', 'contact', 'peak', 'panj', 'market'])
when(self.parser).getMap().thenReturn('buhriz')
self.parser.startup()
self.parser.patch_b3_admin_plugin() # seems that without this the test module doesn't patch the admin plugin
def tearDown(self):
if hasattr(self, "parser"):
del self.parser.clients
self.parser.working = False
class Test_cmd_yell(Bf3TestCase):
def setUp(self):
Bf3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration plugin="poweradminbf3">
<settings name="commands">
<set name="yell">20</set>
</settings>
<settings name="preferences">
<set name="yell_duration">2</set>
</settings>
</configuration>
""")
self.p = Poweradminbf3Plugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
def test_no_argument(self):
self.moderator.connects("moderator")
self.moderator.message_history = []
self.moderator.says("!yell")
self.assertEqual(1, len(self.moderator.message_history))
self.assertEqual('missing parameter, try !help yell', self.moderator.message_history[0])
def test_nominal(self):
self.moderator.connects("moderator")
self.moderator.says("!yell changing map soon !")
self.console.write.assert_called_once_with(('admin.yell', 'changing map soon !', '2'))
class Test_patch_b3_clients_getByMagic(AbstractParser_TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString(
"""
<configuration>
</configuration>
"""
)
self.parser = AbstractParser(self.conf)
# setup context
self.foobar = self.parser.clients.newClient(cid="Foobar", name="Foobar", guid="aaaaaaa5555555")
self.joe = self.parser.clients.newClient(cid="joe", name="joe", guid="bbbbbbbb5555555")
self.jack = self.parser.clients.newClient(cid="jack", name="jack", guid="ccccccccc5555555")
self.jacky = self.parser.clients.newClient(cid="jacky", name="jacky", guid="ddddddddd5555555")
self.p123456 = self.parser.clients.newClient(cid="123456", name="123456", guid="eeeeeee5555555")
def test_exact_name(self):
self.assertEqual([self.foobar], self.parser.clients.getByMagic("Foobar"))
self.assertEqual([self.foobar], self.parser.clients.getByMagic("fOObAr"))
def test_partial_name(self):
self.assertEqual([self.foobar], self.parser.clients.getByMagic("foo"))
self.assertEqual([self.foobar], self.parser.clients.getByMagic("oba"))
self.assertSetEqual(set([self.jacky, self.jack]), set(self.parser.clients.getByMagic("jac")))
self.assertSetEqual(set([self.jacky, self.jack]), set(self.parser.clients.getByMagic("jack")))
def test_player_123456_with_exact_name(self):
self.assertEqual([self.p123456], self.parser.clients.getByMagic("123456"))
def test_player_123456_with_partial_name(self):
"""
This test will fail if the b3.clients.Clients.getByMagic method was not patched
"""
self.assertEqual([self.p123456], self.parser.clients.getByMagic("345"))
def setUp(self):
BF3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.console = Bf3Parser(self.conf)
from b3 import __file__ as b3_module__file__
admin_config_file = os.path.normpath(os.path.join(os.path.dirname(b3_module__file__), "conf/plugin_admin.xml"))
admin_config = XmlConfigParser()
admin_config.load(admin_config_file)
self.adminPlugin = AdminPlugin(self.console, admin_config)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
# monkeypatch the admin plugin
self.console.patch_b3_admin_plugin()
self.changeMap_patcher = patch.object(self.console, "changeMap")
self.changeMap_mock = self.changeMap_patcher.start()
self.player = FakeClient(self.console, name="Player1", guid="Player1GUID", groupBits=128)
self.player.connects("p1")
# GIVEN
self.console.game.gameType = 'ConquestLarge0'
when(self.console).write(('mapList.list', 0)).thenReturn(['4', '3', 'MP_001', 'RushLarge0', '1', 'MP_003',
'ConquestSmall0', '2', 'XP5_001', 'ConquestSmall0',
'2', 'MP_007', 'SquadDeathMatch0', '3'])
when(self.console).write(('mapList.getMapIndices',)).thenReturn(['0', '0'])
class AdminTestCase(unittest.TestCase):
"""
Test case that is suitable for testing EtPro parser specific features with the B3 admin plugin available
"""
@classmethod
def setUpClass(cls):
from b3.fake import FakeConsole
AbstractParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# EtproParser -> AbstractParser -> FakeConsole -> Parser
def setUp(self):
self.status_response = None # defaults to STATUS_RESPONSE module attribute
self.conf = XmlConfigParser()
self.conf.loadFromString("""<configuration></configuration>""")
self.parser = EtproParser(self.conf)
self.parser.output = Mock()
self.parser.output.write = Mock(wraps=sys.stdout.write)
adminPlugin_conf = CfgConfigParser()
adminPlugin_conf.load(ADMIN_CONFIG_FILE)
adminPlugin = AdminPlugin(self.parser, adminPlugin_conf)
adminPlugin.onLoadConfig()
adminPlugin.onStartup()
when(self.parser).getPlugin('admin').thenReturn(adminPlugin)
when(self.parser).getCvar('b_privatemessages').thenReturn(Cvar('b_privatemessages', value='1'))
self.parser.startup()
def tearDown(self):
if hasattr(self, "parser"):
del self.parser.clients
self.parser.working = False
class Iourt41TestCase(unittest.TestCase):
"""
Test case that is suitable for testing iourt41 parser specific features
"""
@classmethod
def setUpClass(cls):
from b3.parsers.q3a.abstractParser import AbstractParser
from b3.fake import FakeConsole
AbstractParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# Iourt41Parser -> AbstractParser -> FakeConsole -> Parser
logging.getLogger('output').setLevel(logging.ERROR)
def setUp(self):
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""
<configuration>
</configuration>
""")
self.console = Iourt41Parser(self.parser_conf)
self.console.PunkBuster = None # no Punkbuster support in that game
self.output_mock = mock()
# simulate game server actions
def write(*args, **kwargs):
pretty_args = map(repr, args) + ["%s=%s" % (k, v) for k, v in kwargs.iteritems()]
log.info("write(%s)" % ', '.join(pretty_args))
return self.output_mock.write(*args, **kwargs)
self.console.write = write
class ChatloggerTestCase(unittest.TestCase):
def setUp(self):
testcase_lock.acquire()
self.addCleanup(cleanUp)
flush_console_streams()
# create a FakeConsole parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(r"""<configuration/>""")
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_conf)
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
self.console.screen = Mock()
self.console.time = time.time
self.console.upTime = Mock(return_value=3)
def tearDown(self):
try:
self.console.storage.shutdown()
except:
pass
class CustomcommandsTestCase(unittest2.TestCase):
def setUp(self):
self.sleep_patcher = patch("time.sleep")
self.sleep_mock = self.sleep_patcher.start()
# create a FakeConsole parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(r"""<configuration/>""")
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_conf)
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
self.adminPlugin._commands = {} # work around known bug in the Admin plugin which makes the _command property shared between all instances
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
self.console.screen = Mock()
self.console.time = time.time
self.console.upTime = Mock(return_value=3)
self.console.cron.stop()
def tearDown(self):
self.sleep_patcher.stop()
class CensorurtTestCase(B3TestCase):
"""
Ease testcases that need an working B3 console and need to control the censorurt plugin config
"""
def setUp(self):
# Timer needs to be patched or the Censor plugin would schedule a 2nd check one minute after
# penalizing a player.
self.timer_patcher = patch('threading.Timer')
self.timer_patcher.start()
self.log = logging.getLogger('output')
self.log.propagate = False
B3TestCase.setUp(self)
self.console.startup()
self.log.propagate = True
self.joe = FakeClient(self.console, name="Joe", exactName="Joe", guid="zaerezarezar", groupBits=1, team=b3.TEAM_UNKNOWN)
self.conf = XmlConfigParser()
self.p = CensorurtPlugin(self.console, self.conf)
def tearDown(self):
B3TestCase.tearDown(self)
self.timer_patcher.stop()
def init_plugin(self, config_content):
self.conf.setXml(config_content)
self.log.setLevel(logging.DEBUG)
self.log.info("============================= Censor plugin: loading config ============================")
self.p.onLoadConfig()
self.log.info("============================= Censor plugin: starting =================================")
self.p.onStartup()
class Test_say(AbstractParser_TestCase):
def setUp(self):
log = logging.getLogger('output')
log.setLevel(logging.NOTSET)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = ConcretegameParser(self.conf)
def test_say(self):
with patch.object(time, 'sleep'):
with patch.object(AbstractParser, 'write') as write_mock:
self.parser._settings['big_b3_private_responses'] = False
self.parser.say('test')
self.parser.say('test2')
self.parser.start_sayqueue_worker()
self.parser.sayqueuelistener.join(.1)
self.assertTrue(write_mock.called)
write_mock.assert_any_call(('admin.say', 'test', 'all'))
write_mock.assert_any_call(('admin.say', 'test2', 'all'))
class Test_patch_b3_clients_getByMagic(AbstractParser_TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = ConcretegameParser(self.conf)
# setup context
self.foobar = self.parser.clients.newClient(cid='Foobar', name='Foobar', guid="aaaaaaa5555555")
self.joe = self.parser.clients.newClient(cid='joe', name='joe', guid="bbbbbbbb5555555")
self.jack = self.parser.clients.newClient(cid='jack', name='jack', guid="ccccccccc5555555")
self.jacky = self.parser.clients.newClient(cid='jacky', name='jacky', guid="ddddddddd5555555")
self.p123456 = self.parser.clients.newClient(cid='123456', name='123456', guid="eeeeeee5555555")
def test_exact_name(self):
self.assertEqual([self.foobar], self.parser.clients.getByMagic('Foobar'))
self.assertEqual([self.foobar], self.parser.clients.getByMagic('fOObAr'))
def test_partial_name(self):
self.assertEqual([self.foobar], self.parser.clients.getByMagic('foo'))
self.assertEqual([self.foobar], self.parser.clients.getByMagic('oba'))
self.assertSetEqual(set([self.jacky, self.jack]), set(self.parser.clients.getByMagic('jac')))
self.assertSetEqual(set([self.jacky, self.jack]), set(self.parser.clients.getByMagic('jack')))
def test_player_123456_with_exact_name(self):
self.assertEqual([self.p123456], self.parser.clients.getByMagic('123456'))
def test_player_123456_with_partial_name(self):
"""
This test will fail if the b3.clients.Clients.getByMagic method was not patched
"""
self.assertEqual([self.p123456], self.parser.clients.getByMagic('345'))
class Test_patch_b3_client_yell(AbstractParser_TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = ConcretegameParser(self.conf)
self.parser._settings['big_msg_duration'] = '3.1'
# setup context
self.joe = self.parser.clients.newClient(cid='joe', name='joe', guid="bbbbbbbb5555555")
def test_client_yell(self):
with patch.object(time, 'sleep'):
with patch.object(AbstractParser, 'write') as write_mock:
self.joe.yell('test')
self.joe.yell('test2')
self.joe.yell('test3')
self.assertTrue(write_mock.called)
write_mock.assert_any_call(('admin.yell', '[pm] test', '3', 'player', 'joe'))
write_mock.assert_any_call(('admin.yell', '[pm] test2', '3', 'player', 'joe'))
write_mock.assert_any_call(('admin.yell', '[pm] test3', '3', 'player', 'joe'))
def test_nominal(self):
conf = XmlConfigParser()
conf.setXml("""
<configuration plugin="teamspeakbf">
<settings name="teamspeakServer">
<set name="host">foo_host</set>
<set name="queryport">foo_queryport</set>
<set name="id">1</set>
<set name="login">foo_login</set>
<set name="password">foo_password</set>
</settings>
<settings name="teamspeakChannels">
<set name="B3">channel name</set>
<set name="team1">Team 1 name</set>
<set name="team2">Team 2 name</set>
<set name="DefaultTarget">team</set>
</settings>
</configuration>
""")
p = TeamspeakbfPlugin(fakeConsole, conf)
p.readConfig()
self.assertEqual('channel name', p.TS3ChannelB3)
self.assertEqual('Team 1 name', p.TS3ChannelTeam1)
self.assertEqual('Team 2 name', p.TS3ChannelTeam2)
self.assertEqual('team', p.autoswitchDefaultTarget)
class B3TestCase(unittest.TestCase):
def setUp(self):
testcase_lock.acquire()
flush_console_streams()
# create a FakeConsole parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(r"""<configuration/>""")
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_conf)
self.console.screen = Mock()
self.console.time = time.time
self.console.upTime = Mock(return_value=3)
self.console.cron.stop()
def myError(msg, *args, **kwargs):
print(("ERROR: %s" % msg) % args)
self.console.error = myError
def tearDown(self):
flush_console_streams()
testcase_lock.release()
class Test_bf3_events(BF3TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = Bf3Parser(self.conf)
self.parser.startup()
def test_cmd_rotateMap_generates_EVT_GAME_ROUND_END(self):
# prepare fake BF3 server responses
def fake_write(data):
if data == ('mapList.getMapIndices', ):
return [0, 1]
else:
return []
self.parser.write = Mock(side_effect=fake_write)
self.parser.getFullMapRotationList = Mock(return_value=MapListBlock(['4', '3', 'MP_007', 'RushLarge0', '4', 'MP_011', 'RushLarge0', '4', 'MP_012',
'SquadRush0', '4', 'MP_013', 'SquadRush0', '4']))
# mock parser queueEvent method so we can make assertions on it later on
self.parser.queueEvent = Mock(name="queueEvent method")
self.parser.rotateMap()
self.assertEqual(1, self.parser.queueEvent.call_count)
self.assertEqual(self.parser.getEventID("EVT_GAME_ROUND_END"), self.parser.queueEvent.call_args[0][0].type)
self.assertIsNone(self.parser.queueEvent.call_args[0][0].data)
class Test_Client_player_type(BFHTestCase):
def setUp(self):
BFHTestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = BfhParser(self.conf)
self.foobar = self.parser.clients.newClient(cid='Foobar', name='Foobar', guid="FoobarGuid")
def test_player_type_player(self):
# GIVEN
when(self.parser).write(('admin.listPlayers', 'player', 'Foobar')).thenReturn(
['10', 'name', 'guid', 'teamId', 'squadId', 'kills', 'deaths', 'score', 'rank', 'ping', 'type', '1',
'Foobar', 'xxxxy', '1', '0', '0', '0', '0', '71', '65535', '0'])
# THEN
self.assertEqual(BFH_PLAYER, self.foobar.player_type)
def test_player_type_spectator(self):
# GIVEN
when(self.parser).write(('admin.listPlayers', 'player', 'Foobar')).thenReturn(
['10', 'name', 'guid', 'teamId', 'squadId', 'kills', 'deaths', 'score', 'rank', 'ping', 'type', '1',
'Foobar', 'xxxxy', '0', '0', '0', '0', '0', '71', '65535', '1'])
# THEN
self.assertEqual(BFH_SPECTATOR, self.foobar.player_type)
class Test_getPlayerPings(BF3TestCase):
def setUp(self):
BF3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = Bf3Parser(self.conf)
self.p1 = FakeClient(self.parser, name="Player1")
self.p2 = FakeClient(self.parser, name="Player2")
def test_no_player(self):
# WHEN
actual_result = self.parser.getPlayerPings()
# THEN
self.assertDictEqual({}, actual_result)
def test_one_player(self):
# GIVEN
self.p1.connects("Player1")
when(self.parser).write(('player.ping', self.p1.cid)).thenReturn(['140'])
# WHEN
actual_result = self.parser.getPlayerPings()
# THEN
self.assertDictEqual({self.p1.cid: 140}, actual_result)
def test_two_player(self):
# GIVEN
self.p1.connects("Player1")
self.p2.connects("Player2")
when(self.parser).write(('player.ping', self.p1.cid)).thenReturn(['140'])
when(self.parser).write(('player.ping', self.p2.cid)).thenReturn(['450'])
# WHEN
actual_result = self.parser.getPlayerPings()
# THEN
self.assertDictEqual({self.p1.cid: 140, self.p2.cid: 450}, actual_result)
def test_bad_data(self):
# GIVEN
self.p1.connects("Player1")
self.p2.connects("Player2")
when(self.parser).write(('player.ping', self.p1.cid)).thenReturn(['140'])
when(self.parser).write(('player.ping', self.p2.cid)).thenReturn(['f00'])
# WHEN
actual_result = self.parser.getPlayerPings()
# THEN
self.assertDictEqual({self.p1.cid: 140}, actual_result)
def test_exception(self):
# GIVEN
self.p1.connects("Player1")
self.p2.connects("Player2")
when(self.parser).write(('player.ping', self.p1.cid)).thenReturn(['140'])
when(self.parser).write(('player.ping', self.p2.cid)).thenRaise(Exception)
# WHEN
actual_result = self.parser.getPlayerPings()
# THEN
self.assertDictEqual({self.p1.cid: 140}, actual_result)
class PluginTestCase(unittest.TestCase):
def setUp(self):
# less logging
logging.getLogger('output').setLevel(logging.ERROR)
# create a parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""<configuration></configuration>""")
self.console = DummyParser(self.parser_conf)
self.console.startup()
# load the admin plugin
if B3version(b3_version) >= B3version("1.10dev"):
admin_plugin_conf_file = '@b3/conf/plugin_admin.ini'
else:
admin_plugin_conf_file = '@b3/conf/plugin_admin.xml'
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, admin_plugin_conf_file)
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
# prepare a few players
self.joe = FakeClient(self.console, name="Joe", guid="joe_guid", groupBits=1)
self.simon = FakeClient(self.console, name="Simon", guid="simon_guid", groupBits=0)
self.moderator = FakeClient(self.console, name="Moderator", guid="moderator_guid", groupBits=8)
logging.getLogger('output').setLevel(logging.DEBUG)
def tearDown(self):
self.console.working = False
class Iourt41TestCase(Iourt41_TestCase_mixin):
"""
Test case that is suitable for testing Iourt41 parser specific features
"""
def setUp(self):
# create a Iourt41 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""<configuration><settings name="server"><set name="game_log"></set></settings></configuration>""")
self.console = Iourt41Parser(self.parser_conf)
self.console.write = Mock(name="write", side_effect=write)
self.console.startup()
# load the admin plugin
if B3version(b3_version) >= B3version("1.10dev"):
admin_plugin_conf_file = '@b3/conf/plugin_admin.ini'
else:
admin_plugin_conf_file = '@b3/conf/plugin_admin.xml'
self.adminPlugin = AdminPlugin(self.console, admin_plugin_conf_file)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
def tearDown(self):
self.console.working = False
class test_others(Arma2TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""<configuration></configuration>""")
self.parser = Arma2Parser(self.conf)
self.parser.output = Mock()
self.parser.startup()
self.player = self.parser.clients.newClient(cid="4", guid="theGuid", name="theName", ip="11.22.33.44")
def test_getBanlist(self):
# GIVEN
self.maxDiff = 1024
when(self.parser.output).write("bans").thenReturn("""\
GUID Bans:
[#] [GUID] [Minutes left] [Reason]
----------------------------------------
0 b57c222222a76f458893641000000005 perm Script Detection: Gerk
1 8ac61111111cd2ff4235140000000026 perm Script Detection: setVehicleInit DoThis;""")
# WHEN
rv = self.parser.getBanlist()
# THEN
self.assertDictEqual({
'b57c222222a76f458893641000000005': {'ban_index': '0', 'guid': 'b57c222222a76f458893641000000005', 'reason': 'Script Detection: Gerk', 'min_left': 'perm'},
'8ac61111111cd2ff4235140000000026': {'ban_index': '1', 'guid': '8ac61111111cd2ff4235140000000026', 'reason': 'Script Detection: setVehicleInit DoThis;', 'min_left': 'perm'},
}, rv)
class EtTestCase(unittest.TestCase):
"""
Test case that is suitable for testing et parser specific features
"""
@classmethod
def setUpClass(cls):
from b3.parsers.q3a.abstractParser import AbstractParser
from b3.fake import FakeConsole
AbstractParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# EtParser -> AbstractParser -> FakeConsole -> Parser
logging.getLogger('output').setLevel(logging.ERROR)
def setUp(self):
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""<configuration>
<settings name="server">
<set name="game_log"/>
</settings>
</configuration>""")
self.console = EtParser(self.parser_conf)
self.console.write = Mock()
self.console.PunkBuster = None # no Punkbuster support in that game
def tearDown(self):
if hasattr(self, "parser"):
del self.parser.clients
self.parser.working = False
class Test_getGamemodeSoundingLike(MohwTestCase):
"""
make sure that getGamemodeSoundingLike returns expected results
"""
def setUp(self):
MohwTestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = MohwParser(self.conf)
def test_CombatMission(self):
self.assertEqual('CombatMission', self.parser.getGamemodeSoundingLike('MP_03', 'CombatMission'))
self.assertEqual('CombatMission', self.parser.getGamemodeSoundingLike('MP_03', 'Combat Mission'))
self.assertEqual('CombatMission', self.parser.getGamemodeSoundingLike('MP_03', 'Combt Mission'))
self.assertEqual('CombatMission', self.parser.getGamemodeSoundingLike('MP_03', 'Mission'))
self.assertEqual('CombatMission', self.parser.getGamemodeSoundingLike('MP_03', 'combat'))
self.assertEqual('CombatMission', self.parser.getGamemodeSoundingLike('MP_03', 'cm'))
def test_Sport(self):
self.assertEqual('Sport', self.parser.getGamemodeSoundingLike('MP_03', 'Sport'))
self.assertEqual('Sport', self.parser.getGamemodeSoundingLike('MP_03', 'Home Run'))
self.assertEqual('Sport', self.parser.getGamemodeSoundingLike('MP_03', 'Home'))
self.assertEqual('Sport', self.parser.getGamemodeSoundingLike('MP_03', 'run'))
self.assertEqual('Sport', self.parser.getGamemodeSoundingLike('MP_03', 'homerun'))
self.assertEqual('Sport', self.parser.getGamemodeSoundingLike('MP_03', 'hr'))
def test_SectorControl(self):
self.assertEqual('SectorControl', self.parser.getGamemodeSoundingLike('MP_03', 'SectorControl'))
self.assertEqual('SectorControl', self.parser.getGamemodeSoundingLike('MP_03', 'Sector Control'))
self.assertEqual('SectorControl', self.parser.getGamemodeSoundingLike('MP_03', 'Sector'))
self.assertEqual('SectorControl', self.parser.getGamemodeSoundingLike('MP_03', 'control'))
self.assertEqual('SectorControl', self.parser.getGamemodeSoundingLike('MP_03', 'sc'))
def test_TeamDeathMatch(self):
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'TeamDeathMatch'))
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'Team DeathMatch'))
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'Team Death Match'))
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'Death Match'))
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'team'))
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'death'))
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'Match'))
self.assertEqual('TeamDeathMatch', self.parser.getGamemodeSoundingLike('MP_03', 'tdm'))
def test_BombSquad(self):
self.assertEqual('BombSquad', self.parser.getGamemodeSoundingLike('MP_03', 'BombSquad'))
self.assertEqual('BombSquad', self.parser.getGamemodeSoundingLike('MP_03', 'Hot Spot'))
self.assertEqual('BombSquad', self.parser.getGamemodeSoundingLike('MP_03', 'Hotspot'))
self.assertEqual('BombSquad', self.parser.getGamemodeSoundingLike('MP_03', 'hot'))
self.assertEqual('BombSquad', self.parser.getGamemodeSoundingLike('MP_03', 'spot'))
self.assertEqual('BombSquad', self.parser.getGamemodeSoundingLike('MP_03', 'Bomb'))
self.assertEqual('BombSquad', self.parser.getGamemodeSoundingLike('MP_03', 'hs'))
def test_suggestions(self):
# unrecognizable input, falling back on available gamemodes for current map
self.assertEqual(['Team Death Match', 'Combat Mission', 'Home Run'],
self.parser.getGamemodeSoundingLike('MP_12', ''))
class CalladminTestCase(unittest2.TestCase):
def setUp(self):
self.sleep_patcher = patch("time.sleep")
self.sleep_mock = self.sleep_patcher.start()
# create a FakeConsole parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(r"""<configuration/>""")
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_conf)
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
self.adminPlugin._commands = {}
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
when(self.console).getCvar('sv_hostname').thenReturn(Cvar(name='sv_hostname', value='Test Server'))
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
when(time).time().thenReturn(60)
def tearDown(self):
self.sleep_patcher.stop()
class Admin_functional_test(B3TestCase):
""" tests from a class inherithing from Admin_functional_test must call self.init() """
def setUp(self):
B3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.p = AdminPlugin(self.console, self.conf)
def init(self, config_content=None):
""" optionally specify a config for the plugin. If called with no parameter, then the default config is loaded """
if config_content is None:
if not os.path.isfile(ADMIN_CONFIG_FILE):
B3TestCase.tearDown(self) # we are skipping the test at a late stage after setUp was called
raise unittest.SkipTest("%s is not a file" % ADMIN_CONFIG_FILE)
else:
self.conf.load(ADMIN_CONFIG_FILE)
else:
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
self.joe = FakeClient(self.console, name="Joe", exactName="Joe", guid="joeguid", groupBits=128, team=TEAM_RED)
self.mike = FakeClient(
self.console, name="Mike", exactName="Mike", guid="mikeguid", groupBits=1, team=TEAM_BLUE
)
class Iourt41TestCase(unittest.TestCase):
"""
Test case that is suitable for testing iourt41 parser specific features
"""
@classmethod
def setUpClass(cls):
# less logging
logging.getLogger('output').setLevel(logging.CRITICAL)
from b3.parsers.q3a.abstractParser import AbstractParser
from b3.fake import FakeConsole
AbstractParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# Iourt41Parser -> AbstractParser -> FakeConsole -> Parser
def setUp(self):
# create a BF3 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""
<configuration>
<settings name="messages">
<set name="kicked_by">$clientname was kicked by $adminname $reason</set>
<set name="kicked">$clientname was kicked $reason</set>
<set name="banned_by">$clientname was banned by $adminname $reason</set>
<set name="banned">$clientname was banned $reason</set>
<set name="temp_banned_by">$clientname was temp banned by $adminname for $banduration $reason</set>
<set name="temp_banned">$clientname was temp banned for $banduration $reason</set>
<set name="unbanned_by">$clientname was un-banned by $adminname $reason</set>
<set name="unbanned">$clientname was un-banned $reason</set>
</settings>
</configuration>
""")
self.console = Iourt41Parser(self.parser_conf)
self.console.startup()
# load the admin plugin
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.xml')
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
def getPlugin(name):
if name == 'admin':
return self.adminPlugin
else:
return self.console.getPlugin(name)
self.console.getPlugin = getPlugin
# prepare a few players
self.joe = FakeClient(self.console, name="Joe", guid="00000000000000000000000000000001", groupBits=1, team=TEAM_UNKNOWN)
self.simon = FakeClient(self.console, name="Simon", guid="00000000000000000000000000000002", groupBits=0, team=TEAM_UNKNOWN)
self.reg = FakeClient(self.console, name="Reg", guid="00000000000000000000000000000003", groupBits=4, team=TEAM_UNKNOWN)
self.moderator = FakeClient(self.console, name="Moderator", guid="00000000000000000000000000000004", groupBits=8, team=TEAM_UNKNOWN)
self.admin = FakeClient(self.console, name="Level-40-Admin", guid="00000000000000000000000000000005", groupBits=16, team=TEAM_UNKNOWN)
self.superadmin = FakeClient(self.console, name="God", guid="00000000000000000000000000000000", groupBits=128, team=TEAM_UNKNOWN)
# more logging
logging.getLogger('output').setLevel(logging.DEBUG)
class Write_controlled_TestCase(AbstractParser_TestCase):
"""
Test case that controls replies given by the parser write method as follow :
## mapList.list
Responds with the maps found on class properties 'maps'.
Response contains 5 maps at most ; to get other maps, you have to use the 'StartOffset' command parameter that appears
from BF3 R12 release.
## mapList.getMapIndices
Responds with the value of the class property 'map_indices'.
## getEasyName
Responds with whatever argument was passed to it.
## getGameMode
Responds with whatever argument was passed to it.
"""
maps = (
('MP_001 ', 'ConquestLarge0', '2'),
('MP_002 ', 'Rush0', '2'),
('MP_003 ', 'ConquestLarge0', '2'),
)
map_indices = [1, 2]
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = ConcretegameParser(self.conf)
self.parser.startup()
# simulate responses we can expect from the rcon command mapList.list
def write(data):
if type(data) in (tuple, list):
if data[0].lower() == 'maplist.list':
offset = 0
if len(data) > 1:
try:
offset = int(data[1])
except ValueError:
raise CommandFailedError(['InvalidArguments'])
# simulate that the Frostbite2 server responds with 5 maps at most for the mapList.list command
maps_to_send = self.__class__.maps[offset:offset + 5]
return [len(maps_to_send), 3] + list(reduce(tuple.__add__, maps_to_send, tuple()))
elif data[0].lower() == 'maplist.getmapindices':
return self.__class__.map_indices
return []
self.parser.write = Mock(side_effect=write)
self.parser.getEasyName = Mock(side_effect=lambda x: x)
self.parser.getGameMode = Mock(side_effect=lambda x: x)
def tearDown(self):
self.parser.working = False
def setUp(self):
B3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.p = AdminPlugin(self.console, self.conf)
class Test_config(AbstractParser_TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""<configuration/>""")
self.parser = ConcretegameParser(self.conf)
log = logging.getLogger('output')
log.setLevel(logging.DEBUG)
def assert_big_b3_private_responses(self, expected, config):
self.parser._settings['big_b3_private_responses'] = None
self.conf.loadFromString(config)
self.parser.load_conf_big_b3_private_responses()
self.assertEqual(expected,
self.parser._settings['big_b3_private_responses'])
def test_big_b3_private_responses_on(self):
self.assert_big_b3_private_responses(
True, """<configuration>
<settings name="thegame">
<set name="big_b3_private_responses">on</set>
</settings>
</configuration>""")
self.assert_big_b3_private_responses(
False, """<configuration>
<settings name="thegame">
<set name="big_b3_private_responses">off</set>
</settings>
</configuration>""")
self.assert_big_b3_private_responses(
False, """<configuration>
<settings name="thegame">
<set name="big_b3_private_responses">off</set>
</settings>
</configuration>""")
self.assert_big_b3_private_responses(
False, """<configuration>
<settings name="thegame">
<set name="big_b3_private_responses">f00</set>
</settings>
</configuration>""")
self.assert_big_b3_private_responses(
False, """<configuration>
<settings name="thegame">
<set name="big_b3_private_responses"></set>
</settings>
</configuration>""")
def assert_big_msg_duration(self, expected, config):
self.parser._settings['big_msg_duration'] = None
self.conf.loadFromString(config)
self.parser.load_conf_big_msg_duration()
self.assertEqual(expected, self.parser._settings['big_msg_duration'])
def test_big_msg_duration(self):
default_value = 4
self.assert_big_msg_duration(
0, """<configuration>
<settings name="thegame">
<set name="big_msg_duration">0</set>
</settings>
</configuration>""")
self.assert_big_msg_duration(
5, """<configuration>
<settings name="thegame">
<set name="big_msg_duration">5</set>
</settings>
</configuration>""")
self.assert_big_msg_duration(
default_value, """<configuration>
<settings name="thegame">
<set name="big_msg_duration">5.6</set>
</settings>
</configuration>""")
self.assert_big_msg_duration(
30, """<configuration>
<settings name="thegame">
<set name="big_msg_duration">30</set>
</settings>
</configuration>""")
self.assert_big_msg_duration(
default_value, """<configuration>
<settings name="thegame">
<set name="big_msg_duration">f00</set>
</settings>
</configuration>""")
self.assert_big_msg_duration(
default_value, """<configuration>
<settings name="thegame">
<set name="big_msg_duration"></set>
</settings>
</configuration>""")
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""<configuration/>""")
self.parser = AbstractParser(self.conf)
log = logging.getLogger('output')
log.setLevel(logging.DEBUG)
class Test_tempban(AbstractParser_TestCase):
def setUp(self):
AbstractParser_TestCase.setUp(self)
log = logging.getLogger('output')
log.setLevel(logging.NOTSET)
self.conf = XmlConfigParser()
self.conf.loadFromString("<configuration/>")
self.parser = ConcretegameParser(self.conf)
self.parser.PunkBuster = None
self.parser.ban_with_server = True
self.getMessage_patcher = patch.object(self.parser, "getMessage")
getMessage_mock = self.getMessage_patcher.start()
getMessage_mock.return_value = ""
self.foo = Mock(spec=Client)
self.foo.cid = 'f00'
self.foo.guid = 'EA_AAABBBBCCCCDDDDEEEEFFFF00000'
self.foo.name = 'f00'
def tearDown(self):
AbstractParser_TestCase.tearDown(self)
self.getMessage_patcher.stop()
def test_kick_having_cid_and_guid(self):
with patch.object(AbstractParser, 'write') as write_mock:
# GIVEN
self.assertTrue(self.foo.cid)
self.assertTrue(self.foo.guid)
# WHEN
self.parser.tempban(self.foo)
# THEN
self.assertTrue(write_mock.called)
write_mock.assert_has_calls([
call(('banList.add', 'guid', self.foo.guid, 'seconds', '120',
''))
])
def test_kick_having_cid_and_empty_guid(self):
with patch.object(AbstractParser, 'write') as write_mock:
# GIVEN
self.foo.guid = ''
self.assertTrue(self.foo.cid)
self.assertFalse(self.foo.guid)
# WHEN
self.parser.tempban(self.foo)
# THEN
self.assertTrue(write_mock.called)
write_mock.assert_has_calls([
call(('banList.add', 'name', self.foo.name, 'seconds', '120',
''))
])
def test_kick_having_no_cid(self):
with patch.object(AbstractParser, 'write') as write_mock:
# GIVEN
self.foo.cid = None
self.assertFalse(self.foo.cid)
# WHEN
self.parser.tempban(self.foo)
# THEN
self.assertTrue(write_mock.called)
write_mock.assert_has_calls([
call(('banList.add', 'guid', self.foo.guid, 'seconds', '120',
''))
])
def setUp(self):
B3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""<configuration/>""")
log = logging.getLogger('output')
log.setLevel(logging.DEBUG)
def test1():
conf = XmlConfigParser()
conf.setXml("""
<configuration plugin="adv">
<!--
Note: within ads, you can use the following variables : @nextmap @time
or rules as defined in the admin plugin config file. ie: /spam#rule1
-->
<settings name="settings">
<!-- rate in minutes-->
<set name="rate">5</set>
<!--
you can either set here a text file that will contain one ad per line
or fill the <ads> section below
-->
<!-- <set name="ads">c:/somewhere/my_ads.txt</set> -->
</settings>
<settings name="newsfeed">
<!--
you can include newsitems in your adds by setting the section below
you can add feeditems in the adds like this:
@feed (will pick the next newsitem each time it is included in the rotation,
rotating until 'items' is reached and then start over.)
@feed 0 (will pick the latest newsitem available from the feed and add it in the rotation)
@feed 1 (will pick the second latest item in line)
etc.
-->
<set name="url">http://forum.bigbrotherbot.net/news-2/?type=rss;action=.xml</set>
<set name="url.bak"></set>
<set name="items">5</set>
<set name="pretext">News: </set>
</settings>
<ads>
<ad>^2Big Brother Bot is watching you... www.BigBrotherBot.net</ad>
<ad>@topstats</ad>
<ad>@feed</ad>
<ad>/spam#rule1</ad>
<ad>@time</ad>
<ad>@feed</ad>
<ad>^2Do you like B3? Consider donating to the project at www.BigBrotherBot.net</ad>
<ad>@nextmap</ad>
</ads>
</configuration>
""")
p = AdvPlugin(fakeConsole, conf)
p.onStartup()
p.adv()
print "-----------------------------"
time.sleep(2)
joe.connects(1)
joe._maxLevel = 100
joe.says('!advlist')
time.sleep(2)
joe.says('!advrem 0')
time.sleep(2)
joe.says('!advrate 5s')
time.sleep(5)
time.sleep(60)
class IpbanTestCase(unittest2.TestCase):
def setUp(self):
if B3version(b3_version) >= B3version("1.10dev"):
from b3.config import MainConfig
self.parser_conf = MainConfig(CfgConfigParser(allow_no_value=True))
self.parser_conf.loadFromString(dedent(r""""""))
admin_plugin_conf_file = '@b3/conf/plugin_admin.ini'
else:
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(
dedent(r"""<configuration></configuration>"""))
admin_plugin_conf_file = '@b3/conf/plugin_admin.xml'
self.console = FakeConsole(self.parser_conf)
self.console.gameName = 'f00'
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console,
admin_plugin_conf_file)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.evt_queue = []
# make sure the admin plugin obtained by other plugins is our admin plugin
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
with logging_disabled():
from b3.fake import FakeClient
# prepare a few players
self.mike = FakeClient(self.console,
name="Mike",
exactName="Mike",
guid="MIKEGUID",
groupBits=16,
ip='1.1.1.1')
self.paul = FakeClient(self.console,
name="Paul",
exactName="Paul",
guid="PAULGUID",
groupBits=1,
ip='2.2.2.2')
self.john = FakeClient(self.console,
name="John",
exactName="John",
guid="JOHNGUID",
groupBits=0,
ip='3.3.3.3')
self.mary = FakeClient(self.console,
name="Mary",
exactName="Mary",
guid="MARYGUID",
groupBits=0,
ip='4.4.4.4')
self.conf = CfgConfigParser()
self.p = IpbanPlugin(self.console, self.conf)
# return some mock data
when(self.p).getBanIps().thenReturn(['2.2.2.2', '6.6.6.6', '7.7.7.7'])
when(self.p).getTempBanIps().thenReturn(
['3.3.3.3', '8.8.8.8', '9.9.9.9'])
def tearDown(self):
self.console.working = False
self.mike.disconnects()
self.paul.disconnects()
self.john.disconnects()
self.mary.disconnects()
def init(self, config_content=None):
if config_content:
self.conf.loadFromString(config_content)
else:
self.conf.loadFromString(
dedent(r"""
[settings]
maxlevel: user
"""))
self.p.onLoadConfig()
self.p.onStartup()
####################################################################################################################
# #
# TEST CONFIG #
# #
####################################################################################################################
def test_with_config_content(self):
# GIVEN
self.init(
dedent(r"""
[settings]
maxlevel: admin
"""))
# THEN
self.assertEqual(self.p._maxLevel, 40)
def test_with_empty_config(self):
# GIVEN
self.init(dedent(r"""
[settings]
"""))
# THEN
self.assertEqual(self.p._maxLevel, 1)
####################################################################################################################
# #
# TEST EVENTS #
# #
####################################################################################################################
def test_higher_group_level_client_connect(self):
# GIVEN
self.init()
self.mike.kick = Mock()
# WHEN
self.mike.connects('1')
# THEN
self.assertGreater(self.mike.maxLevel, self.p._maxLevel)
self.assertEqual(self.mike.kick.call_count, 0)
def test_ip_banned_client_connect(self):
# GIVEN
self.init()
self.paul.kick = Mock()
# WHEN
self.paul.connects('1')
# THEN
self.assertLessEqual(self.paul.maxLevel, self.p._maxLevel)
self.assertIn(self.paul.ip, self.p.getBanIps())
self.paul.kick.assert_called_once_with(
'Netblocker: Client refused: 2.2.2.2 (Paul) has an active Ban')
def test_ip_temp_banned_client_connect(self):
# GIVEN
self.init()
self.john.kick = Mock()
# WHEN
self.john.connects('1')
# THEN
self.assertLessEqual(self.paul.maxLevel, self.p._maxLevel)
self.assertIn(self.john.ip, self.p.getTempBanIps())
self.john.kick.assert_called_once_with(
'Netblocker: Client refused: 3.3.3.3 (John) has an active TempBan')
def test_clean_client_connect(self):
# GIVEN
self.init()
self.mary.kick = Mock()
# WHEN
self.mary.connects('1')
# THEN
self.assertLessEqual(self.paul.maxLevel, self.p._maxLevel)
self.assertNotIn(self.mary.ip, self.p.getBanIps())
self.assertNotIn(self.mary.ip, self.p.getTempBanIps())
self.assertEqual(self.mary.kick.call_count, 0)
class Test_parser_API(Arma2TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""<configuration></configuration>""")
self.parser = Arma2Parser(self.conf)
self.parser.output = Mock()
self.parser.sayqueue.put = Mock(side_effect=self.parser._say)
self.parser.startup()
self.player = self.parser.clients.newClient(cid="4",
guid="theGuid",
name="theName",
ip="11.22.33.44")
def test_getPlayerList(self, sleep_mock):
# GIVEN
when(self.parser.output).write('players').thenReturn(u'''\
Players on server:
[#] [IP Address]:[Port] [Ping] [GUID] [Name]
--------------------------------------------------
0 11.111.11.11:2304 63 80a5885eb00000000000000000000000(OK) étoiléàÄ
0 192.168.0.100:2316 0 80a5885eb00000000000000000000000(OK) étoiléàÄ (Lobby)
(1 players in total)
''')
# WHEN
players = self.parser.getPlayerList()
# THEN
self.maxDiff = 1024
self.assertDictEqual(
{
u'0': {
'cid': u'0',
'guid': u'80a5885eb00000000000000000000000',
'ip': u'192.168.0.100',
'lobby': True,
'name': u'étoiléàÄ',
'ping': u'0',
'port': u'2316',
'verified': u'OK'
}
}, players)
def test_say(self, sleep_mock):
# GIVEN
self.parser.msgPrefix = "[Pre]"
# WHEN
self.parser.say("f00")
# THEN
self.parser.output.write.assert_has_calls([call('say -1 [Pre] f00')])
def test_saybig(self, sleep_mock):
# GIVEN
self.parser.msgPrefix = "[Pre]"
# WHEN
self.parser.saybig("f00")
# THEN
self.parser.output.write.assert_has_calls([call('say -1 [Pre] f00')])
def test_message(self, sleep_mock):
# GIVEN
self.parser.msgPrefix = "[Pre]"
# WHEN
self.parser.message(self.player, "f00")
# THEN
self.parser.output.write.assert_has_calls([call('say 4 [Pre] f00')])
def test_kick(self, sleep_mock):
self.parser.kick(self.player, reason="f00")
self.parser.output.write.assert_has_calls([call('kick 4 f00')])
def test_ban__by_cid(self, sleep_mock):
self.assertIsNotNone(self.player.cid)
self.parser.ban(self.player, reason="f00")
self.parser.output.write.assert_has_calls(
[call('ban 4 0 f00'), call('writeBans')])
def test_ban__by_guid(self, sleep_mock):
self.player.cid = None
self.assertIsNone(self.player.cid)
self.parser.ban(self.player, reason="f00")
self.parser.output.write.assert_has_calls(
[call('addBan theGuid 0 f00'),
call('writeBans')])
def test_unban(self, sleep_mock):
# GIVEN
self.player.cid = None
self.assertIsNone(self.player.cid)
when(self.parser).getBanlist().thenReturn({
'theGuid': {
'ban_index': '152',
'guid': 'theGuid',
'reason': 'the ban reason',
'min_left': 'perm'
},
})
# WHEN
self.parser.unban(self.player, reason="f00")
# THEN
self.parser.output.write.assert_has_calls(
[call('removeBan 152'), call('writeBans')])
def test_tempban__by_cid(self, sleep_mock):
self.assertIsNotNone(self.player.cid)
self.parser.tempban(self.player, reason="f00", duration='2h')
self.parser.output.write.assert_has_calls(
[call('ban 4 120 f00'), call('writeBans')])
def test_tempban__by_guid(self, sleep_mock):
self.player.cid = None
self.assertIsNone(self.player.cid)
self.parser.tempban(self.player, reason="f00", duration='2h')
self.parser.output.write.assert_has_calls(
[call('addBan theGuid 120 f00'),
call('writeBans')])
#
# def test_getMap(self, sleep_mock):
# pass
#
#
# def test_getMaps(self, sleep_mock):
# pass
#
#
# def test_rotateMap(self, sleep_mock):
# pass
#
#
# def test_changeMap(self, sleep_mock):
# pass
def test_getPlayerPings(self, sleep_mock):
# GIVEN
when(self.parser.output).write('players').thenReturn(u'''\
Players on server:
[#] [IP Address]:[Port] [Ping] [GUID] [Name]
--------------------------------------------------
0 76.108.91.78:2304 63 80a5885ebe2420bab5e158a310fcbc7d(OK) Bravo17
0 192.168.0.100:2316 0 80a5885ebe2420bab5e158a310fcbc7d(OK) Bravo17 (Lobby)
2 111.22.3.4:2316 47 80a50000000000000000000000fcbc7d(?) bob
(1 players in total)
''')
# WHEN
pings = self.parser.getPlayerPings()
# THEN
self.maxDiff = 1024
self.assertDictEqual({u'0': 63, u'2': 47}, pings)
class EventParsingTestCase(Arma3TestCase):
def setUp(self):
"""ran before each test"""
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
with logging_disabled():
self.parser = Arma3Parser(self.conf)
self.parser.output = Mock() # mock Rcon
self.evt_queue = []
def queue_event(evt):
self.evt_queue.append(evt)
self.queueEvent_patcher = patch.object(self.parser,
"queueEvent",
wraps=queue_event)
self.queueEvent_mock = self.queueEvent_patcher.start()
self.write_patcher = patch.object(self.parser, "write")
self.write_mock = self.write_patcher.start()
with logging_disabled():
self.parser.startup()
def tearDown(self):
"""ran after each test to clean up"""
Arma3TestCase.tearDown(self)
self.queueEvent_patcher.stop()
self.write_patcher.stop()
if hasattr(self, "parser"):
self.parser.working = False
def clear_events(self):
"""
clear the event queue, so when assert_has_event is called, it will look only at the newly caught events.
"""
self.evt_queue = []
def assert_has_event(self, event_type, data=ANY, client=ANY, target=ANY):
"""
assert that self.evt_queue contains at least one event for the given type that has the given characteristics.
"""
assert isinstance(event_type, str)
def assert_event_equals(expected_event, actual_event):
if expected_event is None:
self.assertIsNone(actual_event)
self.assertEqual(
expected_event.type, actual_event.type,
"expecting type %s, but got %s" %
(self.parser.getEventKey(expected_event.type),
self.parser.getEventKey(actual_event.type)))
if client is not ANY:
self.assertEqual(
expected_event.client, actual_event.client,
"expecting client %s, but got %s" %
(expected_event.client, actual_event.client))
if target is not ANY:
self.assertEqual(
expected_event.target, actual_event.target,
"expecting target %s, but got %s" %
(expected_event.target, actual_event.target))
if data is not ANY:
self.assertEqual(
expected_event.data, actual_event.data,
"expecting data %s, but got %s" %
(expected_event.data, actual_event.data))
expected_event = self.parser.getEvent(event_type, data, client, target)
if not len(self.evt_queue):
self.fail("expecting %s. Got no event instead" % expected_event)
elif len(self.evt_queue) == 1:
assert_event_equals(expected_event, self.evt_queue[0])
else:
for evt in self.evt_queue:
try:
assert_event_equals(expected_event, evt)
return
except AssertionError:
pass
self.fail("expecting event %s. Got instead: %s" %
(expected_event, list(map(str, self.evt_queue))))
from tests import *
prepare_fakeparser_for_tests()
import unittest
import b3
from b3.fake import fakeConsole
from b3.fake import joe
import time
from b3.config import XmlConfigParser
from teamspeak import TeamspeakPlugin
conf = XmlConfigParser()
conf.setXml("""
<configuration plugin="teamspeakbf">
<settings name="teamspeakServer">
<!-- IP or domain where your teamspeak server is hosted -->
<set name="host">{ts_host}</set>
<!-- query port of your teamspeak server (default: 10011) -->
<set name="queryport">{ts_port}</set>
<!-- Teamspeak virtual server ID -->
<set name="id">{ts_id}</set>
<!-- B3 login information. You need to create a ServerQuery Login for B3. video tutorial : http://bit.ly/a5qcjp -->
<set name="login">{ts_login}</set>
<set name="password">{ts_password}</set>
</settings>
<settings name="teamspeakChannels">
<set name="B3">B3 autoswitched channel</set>
<set name="team1">Team 1</set>
<set name="team2">Team 2</set>
class Test_punkbuster_events(BF3TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = Bf3Parser(self.conf)
self.parser.startup()
def pb(self, msg):
return self.parser.OnPunkbusterMessage(action=None, data=[msg])
def assert_pb_misc_evt(self, msg):
assert str(self.pb(msg)).startswith('Event<PunkBuster misc>')
def test_PB_SV_BanList(self):
self.assert_pb_misc_evt(
'PunkBuster Server: 1 b59ffffffffffffffffffffffffffc7d {13/15} "Cucurbitaceae" "87.45.14.2:3659" retest" ""'
)
self.assert_pb_misc_evt(
'PunkBuster Server: 1 b59ffffffffffffffffffffffffffc7d {0/1440} "Cucurbitaceae" "87.45.14.2:3659" mlkjsqfd" ""'
)
self.assertEquals(
'''Event<PunkBuster unknown>(['PunkBuster Server: 1 (UnBanned) b59ffffffffffffffffffffffffffc7d {15/15} "Cucurbitaceae" "87.45.14.2:3659" retest" ""'], None, None)''',
str(
self.
pb('PunkBuster Server: 1 (UnBanned) b59ffffffffffffffffffffffffffc7d {15/15} "Cucurbitaceae" "87.45.14.2:3659" retest" ""'
)))
self.assert_pb_misc_evt(
'PunkBuster Server: Guid=b59ffffffffffffffffffffffffffc7d" Not Found in the Ban List'
)
self.assert_pb_misc_evt(
'PunkBuster Server: End of Ban List (1 of 1 displayed)')
def test_PB_UCON_message(self):
result = self.pb(
'PunkBuster Server: PB UCON "ggc_85.214.107.154"@85.214.107.154:14516 [admin.say "GGC-Stream.com - Welcome Cucurbitaceae with the GUID 31077c7d to our server." all]\n'
)
self.assertEqual(
'Event<PunkBuster UCON>({\'ip\': \'85.214.107.154\', \'cmd\': \'admin.say "GGC-Stream.com - Welcome Cucurbitaceae with the GUID 31077c7d to our server." all\', \'from\': \'ggc_85.214.107.154\', \'port\': \'14516\'}, None, None)',
str(result))
def test_PB_Screenshot_received_message(self):
result = self.pb(
'PunkBuster Server: Screenshot C:\\games\\bf3\\173_199_73_213_25200\\862147\\bf3\\pb\\svss\\pb000709.png successfully received (MD5=4576546546546546546546546543E1E1) from 19 Jaffar [da876546546546546546546546547673(-) 111.22.33.111:3659]\n'
)
self.assertEqual(
r"Event<PunkBuster Screenshot received>({'slot': '19', 'name': 'Jaffar', 'ip': '111.22.33.111', 'pbid': 'da876546546546546546546546547673', 'imgpath': 'C:\\games\\bf3\\173_199_73_213_25200\\862147\\bf3\\pb\\svss\\pb000709.png', 'port': '3659', 'md5': '4576546546546546546546546543E1E1'}, None, None)",
str(result))
def test_PB_SV_PList(self):
self.assert_pb_misc_evt(
"PunkBuster Server: Player List: [Slot #] [GUID] [Address] [Status] [Power] [Auth Rate] [Recent SS] [O/S] [Name]"
)
self.assert_pb_misc_evt(
'PunkBuster Server: End of Player List (0 Players)')
def test_PB_Ver(self):
self.assertIsNone(
self.
pb('PunkBuster Server: PunkBuster Server for BF3 (v1.839 | A1386 C2.279) Enabled\n'
))
def test_PB_SV_BanGuid(self):
self.assert_pb_misc_evt('PunkBuster Server: Ban Added to Ban List')
self.assert_pb_misc_evt('PunkBuster Server: Ban Failed')
def test_PB_SV_UnBanGuid(self):
self.assert_pb_misc_evt(
'PunkBuster Server: Guid b59f190e5ef725e06531387231077c7d has been Unbanned'
)
def test_PB_SV_UpdBanFile(self):
self.assert_pb_misc_evt(
"PunkBuster Server: 0 Ban Records Updated in d:\\localuser\\g119142\\pb\\pbbans.dat"
)
def test_misc(self):
self.assertEqual(
"Event<PunkBuster client connection lost>({'slot': '1', 'ip': 'x.x.x.x', 'port': '3659', 'name': 'joe', 'pbuid': '0837c128293d42aaaaaaaaaaaaaaaaa'}, None, None)",
str(
self.
pb("PunkBuster Server: Lost Connection (slot #1) x.x.x.x:3659 0837c128293d42aaaaaaaaaaaaaaaaa(-) joe"
)))
self.assert_pb_misc_evt(
"PunkBuster Server: Invalid Player Specified: None")
self.assert_pb_misc_evt(
"PunkBuster Server: Matched: Cucurbitaceae (slot #1)")
self.assert_pb_misc_evt(
"PunkBuster Server: Received Master Security Information")
self.assert_pb_misc_evt(
"PunkBuster Server: Auto Screenshot 000714 Requested from 25 Goldbat"
)
# -*- encoding: utf-8 -*-
from tests import prepare_fakeparser_for_tests
prepare_fakeparser_for_tests()
from b3.fake import fakeConsole
from poweradminbf3 import Poweradminbf3Plugin
from b3.config import XmlConfigParser
conf = XmlConfigParser()
conf.loadFromString("""
<configuration plugin="poweradminbf3">
<settings name="commands">
<set name="setmode-mode">60</set>
<set name="roundnext-rnext">40</set>
<set name="roundrestart-rrestart">40</set>
<set name="kill">40</set>
<set name="changeteam">20</set>
<set name="swap">20</set>
<set name="setnextmap-snmap">20</set>
</settings>
<settings name="messages">
<set name="operation_denied">Operation denied</set>
<set name="operation_denied_level">Operation denied because %(name)s is in the %(group)s group</set>
</settings>
</configuration>
""")
# -*- encoding: utf-8 -*-
from tests import prepare_fakeparser_for_tests
prepare_fakeparser_for_tests()
from b3.fake import fakeConsole, joe, simon, superadmin
from poweradminbf3 import Poweradminbf3Plugin
from b3.config import XmlConfigParser
conf = XmlConfigParser()
conf.loadFromString("""
<configuration plugin="poweradminbf3">
<settings name="commands">
<set name="kill">0</set>
</settings>
</configuration>
""")
p = Poweradminbf3Plugin(fakeConsole, conf)
p.onLoadConfig()
p.onStartup()
simon.connects("simon")
simon.teamId = 1
simon.squad = 7
joe.connects('Joe')
joe.teamId = 1
joe.squad = 7
superadmin.connects('superadmin')
superadmin.teamId = 2
superadmin.squad = 6
print "Joe's group is " + joe.maxGroup.name
class Test_getGamemodeSoundingLike(MohwTestCase):
"""
make sure that getGamemodeSoundingLike returns expected results
"""
def setUp(self):
MohwTestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = MohwParser(self.conf)
def test_CombatMission(self):
self.assertEqual(
'CombatMission',
self.parser.getGamemodeSoundingLike('MP_03', 'CombatMission'))
self.assertEqual(
'CombatMission',
self.parser.getGamemodeSoundingLike('MP_03', 'Combat Mission'))
self.assertEqual(
'CombatMission',
self.parser.getGamemodeSoundingLike('MP_03', 'Combt Mission'))
self.assertEqual(
'CombatMission',
self.parser.getGamemodeSoundingLike('MP_03', 'Mission'))
self.assertEqual(
'CombatMission',
self.parser.getGamemodeSoundingLike('MP_03', 'combat'))
self.assertEqual('CombatMission',
self.parser.getGamemodeSoundingLike('MP_03', 'cm'))
def test_Sport(self):
self.assertEqual('Sport',
self.parser.getGamemodeSoundingLike('MP_03', 'Sport'))
self.assertEqual(
'Sport', self.parser.getGamemodeSoundingLike('MP_03', 'Home Run'))
self.assertEqual('Sport',
self.parser.getGamemodeSoundingLike('MP_03', 'Home'))
self.assertEqual('Sport',
self.parser.getGamemodeSoundingLike('MP_03', 'run'))
self.assertEqual(
'Sport', self.parser.getGamemodeSoundingLike('MP_03', 'homerun'))
self.assertEqual('Sport',
self.parser.getGamemodeSoundingLike('MP_03', 'hr'))
def test_SectorControl(self):
self.assertEqual(
'SectorControl',
self.parser.getGamemodeSoundingLike('MP_03', 'SectorControl'))
self.assertEqual(
'SectorControl',
self.parser.getGamemodeSoundingLike('MP_03', 'Sector Control'))
self.assertEqual(
'SectorControl',
self.parser.getGamemodeSoundingLike('MP_03', 'Sector'))
self.assertEqual(
'SectorControl',
self.parser.getGamemodeSoundingLike('MP_03', 'control'))
self.assertEqual('SectorControl',
self.parser.getGamemodeSoundingLike('MP_03', 'sc'))
def test_TeamDeathMatch(self):
self.assertEqual(
'TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'TeamDeathMatch'))
self.assertEqual(
'TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'Team DeathMatch'))
self.assertEqual(
'TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'Team Death Match'))
self.assertEqual(
'TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'Death Match'))
self.assertEqual('TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'team'))
self.assertEqual('TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'death'))
self.assertEqual('TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'Match'))
self.assertEqual('TeamDeathMatch',
self.parser.getGamemodeSoundingLike('MP_03', 'tdm'))
def test_BombSquad(self):
self.assertEqual(
'BombSquad',
self.parser.getGamemodeSoundingLike('MP_03', 'BombSquad'))
self.assertEqual(
'BombSquad',
self.parser.getGamemodeSoundingLike('MP_03', 'Hot Spot'))
self.assertEqual(
'BombSquad',
self.parser.getGamemodeSoundingLike('MP_03', 'Hotspot'))
self.assertEqual('BombSquad',
self.parser.getGamemodeSoundingLike('MP_03', 'hot'))
self.assertEqual('BombSquad',
self.parser.getGamemodeSoundingLike('MP_03', 'spot'))
self.assertEqual('BombSquad',
self.parser.getGamemodeSoundingLike('MP_03', 'Bomb'))
self.assertEqual('BombSquad',
self.parser.getGamemodeSoundingLike('MP_03', 'hs'))
def test_suggestions(self):
# unrecognizable input, falling back on available gamemodes for current map
self.assertEqual(['Team Death Match', 'Combat Mission', 'Home Run'],
self.parser.getGamemodeSoundingLike('MP_12', ''))
def setUp(self):
if B3version(b3_version) >= B3version("1.10dev"):
from b3.config import MainConfig
self.parser_conf = MainConfig(CfgConfigParser(allow_no_value=True))
self.parser_conf.loadFromString(dedent(r""""""))
admin_plugin_conf_file = '@b3/conf/plugin_admin.ini'
else:
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(
dedent(r"""<configuration></configuration>"""))
admin_plugin_conf_file = '@b3/conf/plugin_admin.xml'
self.console = FakeConsole(self.parser_conf)
self.console.gameName = 'f00'
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console,
admin_plugin_conf_file)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.evt_queue = []
# make sure the admin plugin obtained by other plugins is our admin plugin
when(self.console).getPlugin('admin').thenReturn(self.adminPlugin)
with logging_disabled():
from b3.fake import FakeClient
# prepare a few players
self.mike = FakeClient(self.console,
name="Mike",
exactName="Mike",
guid="MIKEGUID",
groupBits=16,
ip='1.1.1.1')
self.paul = FakeClient(self.console,
name="Paul",
exactName="Paul",
guid="PAULGUID",
groupBits=1,
ip='2.2.2.2')
self.john = FakeClient(self.console,
name="John",
exactName="John",
guid="JOHNGUID",
groupBits=0,
ip='3.3.3.3')
self.mary = FakeClient(self.console,
name="Mary",
exactName="Mary",
guid="MARYGUID",
groupBits=0,
ip='4.4.4.4')
self.conf = CfgConfigParser()
self.p = IpbanPlugin(self.console, self.conf)
# return some mock data
when(self.p).getBanIps().thenReturn(['2.2.2.2', '6.6.6.6', '7.7.7.7'])
when(self.p).getTempBanIps().thenReturn(
['3.3.3.3', '8.8.8.8', '9.9.9.9'])
class Test_getMapsSoundingLike(MohwTestCase):
"""
make sure that getMapsSoundingLike returns expected results
"""
def setUp(self):
MohwTestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = MohwParser(self.conf)
def test_MP_03(self):
self.assertEqual('MP_03',
self.parser.getMapsSoundingLike('somalia stronghold'))
self.assertEqual('MP_03',
self.parser.getMapsSoundingLike('somaliastronghold'))
self.assertEqual('MP_03', self.parser.getMapsSoundingLike('somalia'))
self.assertEqual('MP_03',
self.parser.getMapsSoundingLike('stronghold'))
def test_MP_05(self):
self.assertEqual('MP_05',
self.parser.getMapsSoundingLike('novi grad warzone'))
self.assertEqual('MP_05',
self.parser.getMapsSoundingLike('novigradwarzone'))
self.assertEqual('MP_05', self.parser.getMapsSoundingLike('novi'))
self.assertEqual('MP_05', self.parser.getMapsSoundingLike('WARZONE'))
def test_MP_10(self):
self.assertEqual('MP_10',
self.parser.getMapsSoundingLike('sarajevo stadium'))
self.assertEqual('MP_10',
self.parser.getMapsSoundingLike('sarajevostadium'))
self.assertEqual('MP_10', self.parser.getMapsSoundingLike('sarajevo'))
self.assertEqual('MP_10', self.parser.getMapsSoundingLike('stadium'))
def test_MP_12(self):
self.assertEqual('MP_12',
self.parser.getMapsSoundingLike('basilan aftermath'))
self.assertEqual('MP_12',
self.parser.getMapsSoundingLike('basilanaftermath'))
self.assertEqual('MP_12', self.parser.getMapsSoundingLike('basilan'))
self.assertEqual('MP_12', self.parser.getMapsSoundingLike('aftermath'))
def test_MP_13(self):
self.assertEqual('MP_13',
self.parser.getMapsSoundingLike('hara dunes'))
self.assertEqual('MP_13', self.parser.getMapsSoundingLike('haradunes'))
self.assertEqual('MP_13', self.parser.getMapsSoundingLike('hara'))
self.assertEqual('MP_13', self.parser.getMapsSoundingLike('dunes'))
def test_MP_16(self):
self.assertEqual('MP_16',
self.parser.getMapsSoundingLike('al fara cliffside'))
self.assertEqual('MP_16',
self.parser.getMapsSoundingLike('alfaracliffside'))
self.assertEqual('MP_16', self.parser.getMapsSoundingLike('alfara'))
self.assertEqual('MP_16',
self.parser.getMapsSoundingLike('faracliffside'))
self.assertEqual('MP_16', self.parser.getMapsSoundingLike('fara'))
self.assertEqual('MP_16', self.parser.getMapsSoundingLike('cliffside'))
def test_MP_18(self):
self.assertEqual('MP_18',
self.parser.getMapsSoundingLike('shogore valley'))
self.assertEqual('MP_18',
self.parser.getMapsSoundingLike('shogorevalley'))
self.assertEqual('MP_18', self.parser.getMapsSoundingLike('shogore'))
self.assertEqual('MP_18', self.parser.getMapsSoundingLike('valley'))
def test_MP_19(self):
self.assertEqual('MP_19',
self.parser.getMapsSoundingLike('tungunan jungle'))
self.assertEqual('MP_19',
self.parser.getMapsSoundingLike('tungunanjungle'))
self.assertEqual('MP_19', self.parser.getMapsSoundingLike('tungunan'))
self.assertEqual('MP_19', self.parser.getMapsSoundingLike('jungle'))
def test_MP_20(self):
self.assertEqual('MP_20',
self.parser.getMapsSoundingLike('darra gun market'))
self.assertEqual('MP_20',
self.parser.getMapsSoundingLike('darragunmarket'))
self.assertEqual('MP_20', self.parser.getMapsSoundingLike('darra'))
self.assertEqual('MP_20', self.parser.getMapsSoundingLike('darragun'))
self.assertEqual('MP_20', self.parser.getMapsSoundingLike('market'))
def test_MP_21(self):
self.assertEqual('MP_21',
self.parser.getMapsSoundingLike('chitrail compound'))
self.assertEqual('MP_21',
self.parser.getMapsSoundingLike('chitrailcompound'))
self.assertEqual('MP_21', self.parser.getMapsSoundingLike('chitrail'))
self.assertEqual('MP_21', self.parser.getMapsSoundingLike('compound'))
def test_suggestions(self):
self.assertEqual(
['shogore valley', 'sarajevo stadium', 'tungunan jungle'],
self.parser.getMapsSoundingLike(''))
# -*- encoding: utf-8 -*-
import os
from tests import prepare_fakeparser_for_tests
prepare_fakeparser_for_tests()
from b3.fake import fakeConsole
from b3.fake import admin
from poweradminbf3 import Poweradminbf3Plugin
from b3.config import XmlConfigParser
conf = XmlConfigParser()
conf.setXml("""
<configuration plugin="poweradminbf3">
<settings name="commands">
<set name="listconfig">40</set>
</settings>
<settings name="preferences">
<set name="config_path">%(script_dir)s</set>
</settings>
</configuration>
""" % {'script_dir': os.path.abspath(os.path.join(os.path.dirname(__file__), '../extplugins/conf/serverconfigs'))})
p = Poweradminbf3Plugin(fakeConsole, conf)
p.onLoadConfig()
p.onStartup()
admin.connects(2)
admin.says('!listconfig')
# -*- encoding: utf-8 -*-
from tests import *
prepare_fakeparser_for_tests()
from b3.fake import fakeConsole, superadmin
from teamspeakbf import TeamspeakbfPlugin
from b3.config import XmlConfigParser
conf = XmlConfigParser()
conf.loadFromString("""
<configuration plugin="teamspeakbf">
<settings name="teamspeakServer">
<!-- IP or domain where your teamspeak server is hosted -->
<set name="host">{ts_host}</set>
<!-- query port of your teamspeak server (default: 10011) -->
<set name="queryport">{ts_port}</set>
<!-- Teamspeak virtual server ID -->
<set name="id">{ts_id}</set>
<!-- B3 login information. You need to create a ServerQuery Login for B3. video tutorial : http://bit.ly/a5qcjp -->
<set name="login">{ts_login}</set>
<set name="password">{ts_password}</set>
</settings>
<settings name="teamspeakChannels">
<set name="B3">B3 autoswitched channel</set>
<set name="team1">Team 1</set>
<set name="team2">Team 2</set>
</settings>
<settings name="commands">
<set name="tsreconnect">100</set>
<set name="tsdisconnect">100</set>
<set name="teamspeak-ts">0</set>
def save(self):
self.playTime += ( (time.time() - time.timezone) - self.lastEventTime ) / 60
#DelayedSQLObject.save(self)
"""
if __name__ == '__main__':
"""
Automated tests below
"""
from b3.fake import fakeConsole
from b3.fake import superadmin, joe
import time
from b3.config import XmlConfigParser
conf = XmlConfigParser()
conf.setXml("""
<configuration plugin="stats">
<settings name="commands">
<set name="mapstats-mystatalias">0</set>
<set name="testscore-tscr">0</set>
<set name="topstats-tops">2</set>
<set name="topxp-txp">2</set>
</settings>
<settings name="settings">
<set name="startPoints">100</set>
<set name="resetscore">no</set>
<set name="resetxp">no</set>
</settings>
</configuration>
""")
class Test_bf3_maps(BF3TestCase):
def setUp(self):
BF3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = Bf3Parser(self.conf)
def test_each_map_has_at_least_one_gamemode(self):
for map_id in MAP_NAME_BY_ID:
self.assertIn(map_id, GAME_MODES_BY_MAP_ID)
self.assertGreater(len(GAME_MODES_BY_MAP_ID[map_id]), 0)
def test_each_gamemode_is_valid(self):
game_modes_found = set()
map(game_modes_found.update, GAME_MODES_BY_MAP_ID.values())
self.assertSetEqual(set(GAME_MODES_NAMES.keys()), game_modes_found)
for game_mode in game_modes_found:
self.assertIn(game_mode, GAME_MODES_NAMES)
def test_getEasyName(self):
self.assertEqual('Grand Bazaar', self.parser.getEasyName('MP_001'))
self.assertEqual('Tehran Highway', self.parser.getEasyName('MP_003'))
self.assertEqual('Caspian Border', self.parser.getEasyName('MP_007'))
self.assertEqual('Seine Crossing', self.parser.getEasyName('MP_011'))
self.assertEqual('Operation Firestorm',
self.parser.getEasyName('MP_012'))
self.assertEqual('Damavand Peak', self.parser.getEasyName('MP_013'))
self.assertEqual('Noshahar Canals', self.parser.getEasyName('MP_017'))
self.assertEqual('Kharg Island', self.parser.getEasyName('MP_018'))
self.assertEqual('Operation Metro',
self.parser.getEasyName('MP_Subway'))
self.assertEqual('Strike At Karkand',
self.parser.getEasyName('XP1_001'))
self.assertEqual('Gulf of Oman', self.parser.getEasyName('XP1_002'))
self.assertEqual('Sharqi Peninsula',
self.parser.getEasyName('XP1_003'))
self.assertEqual('Wake Island', self.parser.getEasyName('XP1_004'))
self.assertEqual('Scrapmetal', self.parser.getEasyName('XP2_Factory'))
self.assertEqual('Operation 925',
self.parser.getEasyName('XP2_Office'))
self.assertEqual('Donya Fortress',
self.parser.getEasyName('XP2_Palace'))
self.assertEqual('Ziba Tower', self.parser.getEasyName('XP2_Skybar'))
self.assertEqual('Bandar Desert',
self.parser.getEasyName('XP3_Desert'))
self.assertEqual('Alborz Mountains',
self.parser.getEasyName('XP3_Alborz'))
self.assertEqual('Armored Shield',
self.parser.getEasyName('XP3_Shield'))
self.assertEqual('Death Valley', self.parser.getEasyName('XP3_Valley'))
self.assertEqual('Epicenter', self.parser.getEasyName('XP4_Quake'))
self.assertEqual('Markaz Monolith', self.parser.getEasyName('XP4_FD'))
self.assertEqual('Azadi Palace', self.parser.getEasyName('XP4_Parl'))
self.assertEqual('Talah market', self.parser.getEasyName('XP4_Rubble'))
self.assertEqual('f00', self.parser.getEasyName('f00'))
def test_getHardName(self):
self.assertEqual('MP_001', self.parser.getHardName('Grand Bazaar'))
self.assertEqual('MP_003', self.parser.getHardName('Tehran Highway'))
self.assertEqual('MP_007', self.parser.getHardName('Caspian Border'))
self.assertEqual('MP_011', self.parser.getHardName('Seine Crossing'))
self.assertEqual('MP_012',
self.parser.getHardName('Operation Firestorm'))
self.assertEqual('MP_013', self.parser.getHardName('Damavand Peak'))
self.assertEqual('MP_017', self.parser.getHardName('Noshahar Canals'))
self.assertEqual('MP_018', self.parser.getHardName('Kharg Island'))
self.assertEqual('MP_Subway',
self.parser.getHardName('Operation Metro'))
self.assertEqual('XP1_001',
self.parser.getHardName('Strike At Karkand'))
self.assertEqual('XP1_002', self.parser.getHardName('Gulf of Oman'))
self.assertEqual('XP1_003',
self.parser.getHardName('Sharqi Peninsula'))
self.assertEqual('XP1_004', self.parser.getHardName('Wake Island'))
self.assertEqual('XP2_Factory', self.parser.getHardName('Scrapmetal'))
self.assertEqual('XP2_Office',
self.parser.getHardName('Operation 925'))
self.assertEqual('XP2_Palace',
self.parser.getHardName('Donya Fortress'))
self.assertEqual('XP2_Skybar', self.parser.getHardName('Ziba Tower'))
self.assertEqual('XP3_Desert',
self.parser.getHardName('Bandar Desert'))
self.assertEqual('XP3_Alborz',
self.parser.getHardName('Alborz Mountains'))
self.assertEqual('XP3_Shield',
self.parser.getHardName('Armored Shield'))
self.assertEqual('XP3_Valley', self.parser.getHardName('Death Valley'))
self.assertEqual('XP4_Quake', self.parser.getHardName('Epicenter'))
self.assertEqual('XP4_FD', self.parser.getHardName('Markaz Monolith'))
self.assertEqual('XP4_Parl', self.parser.getHardName('Azadi Palace'))
self.assertEqual('XP4_Rubble', self.parser.getHardName('Talah market'))
self.assertEqual('f00', self.parser.getHardName('f00'))
def test_getMapsSoundingLike(self):
self.assertEqual(['operation metro', 'gulf of oman', 'seine crossing'],
self.parser.getMapsSoundingLike(''), '')
self.assertEqual('MP_Subway',
self.parser.getMapsSoundingLike('Operation Metro'),
'Operation Metro')
self.assertEqual('MP_001', self.parser.getMapsSoundingLike('grand'))
self.assertEqual(
['operation metro', 'operation firestorm', 'operation 925'],
self.parser.getMapsSoundingLike('operation'))
self.assertEqual('XP3_Desert',
self.parser.getMapsSoundingLike('bandar'))
self.assertEqual('XP3_Desert',
self.parser.getMapsSoundingLike('desert'))
self.assertEqual('XP3_Alborz',
self.parser.getMapsSoundingLike('alborz'))
self.assertEqual('XP3_Alborz',
self.parser.getMapsSoundingLike('mountains'))
self.assertEqual('XP3_Alborz',
self.parser.getMapsSoundingLike('mount'))
self.assertEqual('XP3_Shield',
self.parser.getMapsSoundingLike('armored'))
self.assertEqual('XP3_Shield',
self.parser.getMapsSoundingLike('shield'))
self.assertEqual('XP3_Valley',
self.parser.getMapsSoundingLike('Death'))
self.assertEqual('XP3_Valley',
self.parser.getMapsSoundingLike('valley'))
self.assertEqual('XP4_Quake',
self.parser.getMapsSoundingLike('Epicenter'))
self.assertEqual('XP4_Quake',
self.parser.getMapsSoundingLike('Epicentre'))
self.assertEqual('XP4_Quake', self.parser.getMapsSoundingLike('epi'))
self.assertEqual('XP4_FD',
self.parser.getMapsSoundingLike('markaz Monolith'))
self.assertEqual('XP4_FD',
self.parser.getMapsSoundingLike('markazMonolith'))
self.assertEqual('XP4_FD',
self.parser.getMapsSoundingLike('markaz Monolit'))
self.assertEqual('XP4_FD',
self.parser.getMapsSoundingLike('markaz Mono'))
self.assertEqual('XP4_FD', self.parser.getMapsSoundingLike('markaz'))
self.assertEqual('XP4_FD', self.parser.getMapsSoundingLike('Monolith'))
self.assertEqual('XP4_Parl',
self.parser.getMapsSoundingLike('Azadi Palace'))
self.assertEqual('XP4_Parl',
self.parser.getMapsSoundingLike('AzadiPalace'))
self.assertEqual('XP4_Parl', self.parser.getMapsSoundingLike('Azadi'))
self.assertEqual('XP4_Parl', self.parser.getMapsSoundingLike('Palace'))
self.assertEqual('XP4_Parl',
self.parser.getMapsSoundingLike('Azadi Place'))
self.assertEqual('XP4_Rubble',
self.parser.getMapsSoundingLike('Talah market'))
self.assertEqual('XP4_Rubble',
self.parser.getMapsSoundingLike('Talahmarket'))
self.assertEqual('XP4_Rubble',
self.parser.getMapsSoundingLike('Talah'))
self.assertEqual('XP4_Rubble',
self.parser.getMapsSoundingLike('market'))
def test_getGamemodeSoundingLike(self):
self.assertEqual(
'ConquestSmall0',
self.parser.getGamemodeSoundingLike('MP_011', 'ConquestSmall0'),
'ConquestSmall0')
self.assertEqual(
'ConquestSmall0',
self.parser.getGamemodeSoundingLike('MP_011', 'Conquest'),
'Conquest')
self.assertListEqual(['Team Deathmatch', 'Squad Deathmatch'],
self.parser.getGamemodeSoundingLike(
'MP_011', 'Deathmatch'), 'Deathmatch')
self.assertListEqual(['Rush', 'Conquest', 'Conquest64'],
self.parser.getGamemodeSoundingLike(
'MP_011', 'foo'))
self.assertEqual('TeamDeathMatch0',
self.parser.getGamemodeSoundingLike('MP_011', 'tdm'),
'tdm')
self.assertEqual(
'TeamDeathMatch0',
self.parser.getGamemodeSoundingLike('MP_011', 'teamdeathmatch'),
'teamdeathmatch')
self.assertEqual(
'TeamDeathMatch0',
self.parser.getGamemodeSoundingLike('MP_011', 'team death match'),
'team death match')
self.assertEqual('ConquestLarge0',
self.parser.getGamemodeSoundingLike('MP_011', 'CQ64'),
'CQ64')
self.assertEqual(
'TankSuperiority0',
self.parser.getGamemodeSoundingLike('XP3_Valley',
'tank superiority'),
'tank superiority')
self.assertEqual(
'TankSuperiority0',
self.parser.getGamemodeSoundingLike('XP3_Valley',
'tanksuperiority'),
'tanksuperiority')
self.assertEqual(
'TankSuperiority0',
self.parser.getGamemodeSoundingLike('XP3_Valley', 'tanksup'),
'tanksup')
self.assertEqual(
'TankSuperiority0',
self.parser.getGamemodeSoundingLike('XP3_Valley', 'tank'), 'tank')
self.assertEqual(
'SquadDeathMatch0',
self.parser.getGamemodeSoundingLike('XP4_Quake', 'sqdm'), 'sqdm')
self.assertEqual(
'Scavenger0',
self.parser.getGamemodeSoundingLike('XP4_Quake', 'scavenger'),
'scavenger')
self.assertEqual(
'Scavenger0',
self.parser.getGamemodeSoundingLike('XP4_Quake', 'scav'), 'scav')
self.assertEqual('Scavenger0',
self.parser.getGamemodeSoundingLike('XP4_FD', 'scav'),
'scav')
self.assertEqual(
'Scavenger0',
self.parser.getGamemodeSoundingLike('XP4_Parl', 'scav'), 'scav')
self.assertEqual(
'Scavenger0',
self.parser.getGamemodeSoundingLike('XP4_Rubble', 'scav'), 'scav')
def setUp(self):
# create a B3 FakeConsole
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(r"""<configuration/>""")
self.console = FakeConsole(self.parser_conf)
# create our plugin instance
self.plugin_conf = CfgConfigParser()
self.p = Weaponlimiterbf3Plugin(self.console, self.plugin_conf)
# initialise the plugin
self.plugin_conf.loadFromString(r'''
[commands]
weaponlimiter-wpl: 60
weaponlimits: guest
noobkill: 20
[settings]
change servermessage: yes
self_kill_counter: 1
config_strategy: mapname
display_extra_msg: message
yell_duration: 10
[punisher]
kill_player: no
warn_player: yes
[messages]
servermessage: This game uses weapons limits. Use !weaponlimits to show forbidden weapons.
weaponlimiter_enabled: WeaponLimiter for that round activated!
weaponlimiter_disabled: Weaponlimiter disabled! All Weapons allowed.
warn_message: You used a forbidden weapon! ^7!forbidden_weapons show the list of forbidden weapons
forbidden_message: Forbidden Weapons are: %s
allowed_message: Allowed Weapons: %s
extra_warning_message: You have %(victim)s killed with a %(weapon)s. This weapon is forbidden!
[XP2_Skybar]
banned weapons: SMAW, M320, RPG-7, USAS-12
gametype: Domination0
weapons: Weapons/Gadgets/C4/C4,870MCS,DAO-12,jackhammer,M1014,M26Mass,Siaga20k,SPAS-12,USAS-12
''')
# fake BF3 game
self.console.game.gameName = 'bf3'
self.console.game.gameType = 'Domination0'
self.console.game._mapName = 'XP2_Skybar'
# startup plugin
self.p.onLoadConfig()
self.p.onStartup()
# enable
self.p._wpl_is_active = True
# prepare a few players
self.joe = FakeClient(self.console,
name="Joe",
exactName="Joe",
guid="zaerezarezar",
groupBits=1)
self.simon = FakeClient(self.console,
name="Simon",
exactName="Simon",
guid="qsdfdsqfdsqf",
groupBits=0)
self.admin = FakeClient(
self.console,
name="Level-40-Admin",
exactName="Level-40-Admin",
guid="875sasda",
groupBits=16,
)
self.superadmin = FakeClient(self.console,
name="God",
exactName="God",
guid="f4qfer654r",
groupBits=128)
class Test_bf3_sends_no_guid(BF3TestCase):
"""
See bug https://github.com/courgette/big-brother-bot/issues/69
"""
def setUp(self):
BF3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.loadFromString("<configuration/>")
self.parser = Bf3Parser(self.conf)
self.parser.startup()
self.authorizeClients_patcher = patch.object(self.parser.clients,
"authorizeClients")
self.authorizeClients_patcher.start()
self.write_patcher = patch.object(self.parser, "write")
self.write_mock = self.write_patcher.start()
self.event_raw_data = 'PunkBuster Server: 14 300000aaaaaabbbbbbccccc111223300(-) 11.122.103.24:3659 OK 1 3.0 0 (W) "Snoopy"'
self.regex_for_OnPBPlistItem = [
x for (x, y) in self.parser._punkbusterMessageFormats
if y == 'OnPBPlistItem'
][0]
def tearDown(self):
BF3TestCase.tearDown(self)
self.authorizeClients_patcher.stop()
self.write_mock = self.write_patcher.stop()
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_does_not_auth_client_without_guid_and_unknown_pbid(self):
# GIVEN
# 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.assertFalse(snoopy.authed)
class Test_getFullBanList(AbstractParser_TestCase):
"""
getFullBanList is a method of AbstractParser that calls the Frostbite2 banList.list command the number of
times required to obtain the exhaustive list of bans.
"""
bans = (
('name', 'Joe', 'perm', '0', '0', 'Banned by admin'),
('name', 'Jack', 'rounds', '0', '4', 'tk'),
('name', 'Averell', 'seconds', '3576', '0', 'being stupid'),
('name', 'William', 'perm', '0', '0', 'hacking'),
)
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = ConcretegameParser(self.conf)
self.parser.startup()
# simulate responses we can expect from the rcon command mapList.list
def write(data):
if type(data) in (tuple, list):
if data[0].lower() == 'banlist.list':
offset = 0
if len(data) > 1:
try:
offset = int(data[1])
except ValueError:
raise CommandFailedError(['InvalidArguments'])
# simulate that the Frostbite2 server responds with 5 bans at most for the banList.list command
bans_to_send = self.__class__.bans[offset:offset + 5]
return list(reduce(tuple.__add__, bans_to_send, tuple()))
return []
self.parser.write = Mock(side_effect=write)
def test_empty(self):
# setup context
self.__class__.bans = tuple()
# verify
bl = self.parser.getFullBanList()
self.assertEqual(0, len(bl))
self.assertEqual(1, self.parser.write.call_count)
def test_one_ban(self):
# setup context
self.__class__.bans = (('name', 'Foo1 ', 'perm', '0', '0',
'Banned by admin'), )
# verify
mlb = self.parser.getFullBanList()
self.assertEqual(
"BanlistContent[{'idType': 'name', 'seconds_left': '0', 'reason': 'Banned by admin', 'banType': 'perm', 'rounds_left': '0', 'id': 'Foo1 '}]",
repr(mlb))
self.assertEqual(2, self.parser.write.call_count)
def test_two_bans(self):
# setup context
self.__class__.bans = (
('name', 'Foo1 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo2 ', 'perm', '0', '0', 'Banned by admin'),
)
# verify
mlb = self.parser.getFullBanList()
self.assertEqual(
"BanlistContent[{'idType': 'name', 'seconds_left': '0', 'reason': 'Banned by admin', 'banType': 'perm', 'rounds_left': '0', 'id': 'Foo1 '}, \
{'idType': 'name', 'seconds_left': '0', 'reason': 'Banned by admin', 'banType': 'perm', 'rounds_left': '0', 'id': 'Foo2 '}]",
repr(mlb))
self.assertEqual(2, self.parser.write.call_count)
def test_lots_of_bans(self):
# setup context
self.__class__.bans = (
('name', 'Foo1 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo2 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo3 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo4 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo5 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo6 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo7 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo8 ', 'perm', '0', '0', 'Banned by admin'),
('name', 'Foo9 ', 'perm', '0', '0', 'Banned by admin'),
)
# verify
mlb = self.parser.getFullBanList()
self.assertEqual(9, len(mlb))
# check in details what were the 3 calls made to the write method
assert [
((('banList.list', 0), ), {}),
((('banList.list', 5), ), {}),
((('banList.list', 10), ), {}),
], self.parser.write.call_args_list
class Test_bf3_events(BF3TestCase):
def setUp(self):
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = Bf3Parser(self.conf)
self.parser.startup()
# mock parser queueEvent method so we can make assertions on it later on
self.parser.queueEvent = Mock(name="queueEvent method")
self.joe = Mock(name="Joe", spec=Client)
def test_cmd_rotateMap_generates_EVT_GAME_ROUND_END(self):
# prepare fake BF3 server responses
def fake_write(data):
if data == ('mapList.getMapIndices', ):
return [0, 1]
else:
return []
self.parser.write = Mock(side_effect=fake_write)
self.parser.getFullMapRotationList = Mock(return_value=MapListBlock([
'4', '3', 'MP_007', 'RushLarge0', '4', 'MP_011', 'RushLarge0', '4',
'MP_012', 'SquadRush0', '4', 'MP_013', 'SquadRush0', '4'
]))
self.parser.rotateMap()
self.assertEqual(1, self.parser.queueEvent.call_count)
self.assertEqual(self.parser.getEventID("EVT_GAME_ROUND_END"),
self.parser.queueEvent.call_args[0][0].type)
self.assertIsNone(self.parser.queueEvent.call_args[0][0].data)
def test_player_onChat_event_all(self):
self.parser.getClient = Mock(return_value=self.joe)
self.parser.routeFrostbitePacket(
['player.onChat', 'Cucurbitaceae', 'test all', 'all'])
self.assertEqual(1, self.parser.queueEvent.call_count)
event = self.parser.queueEvent.call_args[0][0]
self.assertEqual("Say", self.parser.getEventName(event.type))
self.assertEquals('test all', event.data)
self.assertEqual(self.joe, event.client)
def test_player_onChat_event_team(self):
self.parser.getClient = Mock(return_value=self.joe)
self.parser.routeFrostbitePacket(
['player.onChat', 'Cucurbitaceae', 'test team', 'team', '1'])
self.assertEqual(1, self.parser.queueEvent.call_count)
event = self.parser.queueEvent.call_args[0][0]
self.assertEqual("Team Say", self.parser.getEventName(event.type))
self.assertEquals('test team', event.data)
self.assertEqual(self.joe, event.client)
def test_player_onChat_event_squad(self):
self.parser.getClient = Mock(return_value=self.joe)
self.parser.routeFrostbitePacket([
'player.onChat', 'Cucurbitaceae', 'test squad', 'squad', '1', '1'
])
self.assertEqual(1, self.parser.queueEvent.call_count)
event = self.parser.queueEvent.call_args[0][0]
self.assertEqual("Team Say", self.parser.getEventName(event.type))
self.assertEquals('test squad', event.data)
self.assertEqual(self.joe, event.client)
class Test_OnPlayerChat(AbstractParser_TestCase):
def setUp(self):
log = logging.getLogger('output')
log.setLevel(logging.NOTSET)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = ConcretegameParser(self.conf)
self.admin_plugin_mock = Mock(spec=AdminPlugin)
self.admin_plugin_mock._commands = {}
self.admin_plugin_mock.cmdPrefix = '!'
self.admin_plugin_mock.cmdPrefixLoud = '@'
self.admin_plugin_mock.cmdPrefixBig = '&'
self.parser.getPlugin = Mock(return_value=self.admin_plugin_mock)
self.joe = Mock(spec=Client)
self.parser.getClient = Mock(return_value=self.joe)
def test_normal_text(self):
self.assertEqual(
'foo',
self.parser.OnPlayerChat(action=None,
data=('joe', 'foo', 'all')).data)
self.assertEqual(
' foo',
self.parser.OnPlayerChat(action=None,
data=('joe', ' foo', 'all')).data)
def test_command(self):
self.assertEqual(
'!1',
self.parser.OnPlayerChat(action=None,
data=('joe', '!1', 'all')).data)
self.assertEqual(
'!foo',
self.parser.OnPlayerChat(action=None,
data=('joe', '!foo', 'all')).data)
self.assertEqual(
'!!foo',
self.parser.OnPlayerChat(action=None,
data=('joe', '!!foo', 'all')).data)
self.assertEqual(
'@foo',
self.parser.OnPlayerChat(action=None,
data=('joe', '@foo', 'all')).data)
self.assertEqual(
'@@foo',
self.parser.OnPlayerChat(action=None,
data=('joe', '@@foo', 'all')).data)
self.assertEqual(
r'&foo',
self.parser.OnPlayerChat(action=None,
data=('joe', r'&foo', 'all')).data)
self.assertEqual(
r'&&foo',
self.parser.OnPlayerChat(action=None,
data=('joe', r'&&foo', 'all')).data)
def test_slash_prefix(self):
self.assertEqual(
'!1',
self.parser.OnPlayerChat(action=None,
data=('joe', '/!1', 'all')).data)
self.assertEqual(
'!foo',
self.parser.OnPlayerChat(action=None,
data=('joe', '/!foo', 'all')).data)
self.assertEqual(
'@foo',
self.parser.OnPlayerChat(action=None,
data=('joe', '/@foo', 'all')).data)
self.assertEqual(
r'&foo',
self.parser.OnPlayerChat(action=None,
data=('joe', r'/&foo', 'all')).data)
def test_slash_no_prefix_no_command(self):
self.assertNotIn('non_existing_command',
self.admin_plugin_mock._commands)
self.assertEqual(
'/non_existing_command',
self.parser.OnPlayerChat(action=None,
data=('joe', '/non_existing_command',
'all')).data)
def test_slash_no_prefix_command(self):
self.admin_plugin_mock._commands['exiting_command'] = Mock()
self.assertIn('exiting_command', self.admin_plugin_mock._commands)
self.assertEqual(
'!exiting_command',
self.parser.OnPlayerChat(action=None,
data=('joe', '/exiting_command',
'all')).data)
self.assertEqual(
'!exiting_command',
self.parser.OnPlayerChat(action=None,
data=('joe', '!exiting_command',
'all')).data)
self.admin_plugin_mock._commands['a'] = Mock()
self.assertIn('a', self.admin_plugin_mock._commands)
self.assertEqual(
'!a',
self.parser.OnPlayerChat(action=None,
data=('joe', '/a', 'all')).data)
self.assertEqual(
'!a',
self.parser.OnPlayerChat(action=None,
data=('joe', '!a', 'all')).data)
# -*- encoding: utf-8 -*-
import os
import b3
import time
from tests import prepare_fakeparser_for_tests
prepare_fakeparser_for_tests()
from b3.fake import fakeConsole
from poweradminbf3 import Poweradminbf3Plugin
from b3.config import XmlConfigParser
conf = XmlConfigParser()
conf.setXml("""
<configuration plugin="poweradminbf3">
<settings name="configmanager">
<set name="status">on</set>
</settings>
</configuration>
""")
# make B3 think it has a config file on the filesystem
conf.fileName = os.path.join(os.path.dirname(__file__),
'../extplugins/conf/plugin_poweradminbf3.xml')
time.sleep(.5)
print "-" * 50
p = Poweradminbf3Plugin(fakeConsole, conf)
p.onLoadConfig()
p.onStartup()
class Bf3TestCase(unittest.TestCase):
"""
Test case that is suitable for testing BF3 parser specific features
"""
@classmethod
def setUpClass(cls):
# less logging
logging.getLogger('output').setLevel(logging.ERROR)
with logging_disabled():
from b3.parsers.frostbite2.abstractParser import AbstractParser
from b3.fake import FakeConsole
AbstractParser.__bases__ = (FakeConsole, )
# Now parser inheritance hierarchy is :
# Bf3Parser -> AbstractParser -> FakeConsole -> Parser
# add method changes_team(newTeam, newSquad=None) to FakeClient
def changes_team(self, newTeam, newSquad=None):
self.console.OnPlayerTeamchange(
None,
data=[self.cid, newTeam, newSquad if newSquad else self.squad])
from b3.fake import FakeClient
FakeClient.changes_team = changes_team
def setUp(self):
# create a BF3 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""<configuration />""")
with logging_disabled():
self.console = Bf3Parser(self.parser_conf)
# alter a few settings to speed up the tests
self.console.sayqueue_get_timeout = 0
self.console._message_delay = 0
with logging_disabled():
self.console.startup()
# load the admin plugin
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
def getPlugin(name):
if name == 'admin':
return self.adminPlugin
else:
return self.console.getPlugin(name)
self.console.getPlugin = getPlugin
self.console.patch_b3_admin_plugin()
# prepare a few players
with logging_disabled():
from b3.fake import FakeClient
self.joe = FakeClient(self.console,
name="Joe",
exactName="Joe",
guid="zaerezarezar",
groupBits=1,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.simon = FakeClient(self.console,
name="Simon",
exactName="Simon",
guid="qsdfdsqfdsqf",
groupBits=0,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.reg = FakeClient(self.console,
name="Reg",
exactName="Reg",
guid="qsdfdsqfdsqf33",
groupBits=4,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.moderator = FakeClient(self.console,
name="Moderator",
exactName="Moderator",
guid="sdf455ezr",
groupBits=8,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.admin = FakeClient(self.console,
name="Level-40-Admin",
exactName="Level-40-Admin",
guid="875sasda",
groupBits=16,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.superadmin = FakeClient(self.console,
name="God",
exactName="God",
guid="f4qfer654r",
groupBits=128,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
def tearDown(self):
self.console.working = False
self.console.wait_for_threads()
sys.stdout.write("\tactive threads count : %s " %
threading.activeCount())
class Test_OnPBPlayerGuid(AbstractParser_TestCase):
def setUp(self):
log = logging.getLogger('output')
log.setLevel(logging.NOTSET)
self.conf = XmlConfigParser()
self.conf.loadFromString("""
<configuration>
</configuration>
""")
self.parser = ConcretegameParser(self.conf)
self.event_raw_data = [
"punkBuster.onMessage",
'PunkBuster Server: 14 300000aaaaaabbbbbbccccc111223300(-) 11.122.103.24:3659 OK 1 3.0 0 (W) "Snoopy"'
]
regex_for_OnPBPlistItem = [
x for (x, y) in self.parser._punkbusterMessageFormats
if y == 'OnPBPlistItem'
][0]
self.event_match = Mock(
wraps=re.match(regex_for_OnPBPlistItem, self.event_raw_data[1]))
self.event_match.__eq__ = Test_OnPBPlayerGuid.SREMatch_equals
@staticmethod
def SREMatch_equals(m1, m2):
"""
@return True if m1 and m2 could be re.match responses for the same regex and data to match
"""
if m2 is None:
return False
else:
return m1.groups() == m2.groups()
def test_OnPBPlistItem_is_called(self):
with patch.object(self.parser, "OnPBPlistItem") as OnPBPlistItem_mock:
# WHEN
self.parser.routeFrostbitePacket(self.event_raw_data)
# THEN
OnPBPlistItem_mock.assert_called_once_with(self.event_match,
self.event_raw_data[1])
def test_OnPBPlayerGuid_is_called(self):
with patch.object(self.parser,
"OnPBPlayerGuid") as OnPBPlayerGuid_mock:
# WHEN
self.parser.routeFrostbitePacket(self.event_raw_data)
# THEN
OnPBPlayerGuid_mock.assert_called_once_with(
self.event_match, self.event_raw_data[1])
def test_OnPBPlayerGuid_saves_client_with_guid(self):
with patch.object(self.parser, "getClient") as getClient_mock:
# GIVEN
snoopy = Mock()
snoopy.guid = 'EA_AAAAAAAABBBBBBBBBBBBBB00000000000012222'
getClient_mock.return_value = snoopy
# WHEN
self.parser.routeFrostbitePacket(self.event_raw_data)
# THEN
getClient_mock.assert_called_once_with("Snoopy")
snoopy.save.assert_called_once_with()
def test_OnPBPlayerGuid_does_not_save_client_without_guid(self):
with patch.object(self.parser, "getClient") as getClient_mock:
# GIVEN
snoopy = Mock()
snoopy.guid = ''
getClient_mock.return_value = snoopy
# WHEN
self.parser.routeFrostbitePacket(self.event_raw_data)
# THEN
getClient_mock.assert_called_once_with("Snoopy")
self.assertFalse(snoopy.save.called)
def setUp(self):
# create a BF3 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""<configuration />""")
with logging_disabled():
self.console = Bf3Parser(self.parser_conf)
# alter a few settings to speed up the tests
self.console.sayqueue_get_timeout = 0
self.console._message_delay = 0
with logging_disabled():
self.console.startup()
# load the admin plugin
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
self.adminPlugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
def getPlugin(name):
if name == 'admin':
return self.adminPlugin
else:
return self.console.getPlugin(name)
self.console.getPlugin = getPlugin
self.console.patch_b3_admin_plugin()
# prepare a few players
with logging_disabled():
from b3.fake import FakeClient
self.joe = FakeClient(self.console,
name="Joe",
exactName="Joe",
guid="zaerezarezar",
groupBits=1,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.simon = FakeClient(self.console,
name="Simon",
exactName="Simon",
guid="qsdfdsqfdsqf",
groupBits=0,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.reg = FakeClient(self.console,
name="Reg",
exactName="Reg",
guid="qsdfdsqfdsqf33",
groupBits=4,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.moderator = FakeClient(self.console,
name="Moderator",
exactName="Moderator",
guid="sdf455ezr",
groupBits=8,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.admin = FakeClient(self.console,
name="Level-40-Admin",
exactName="Level-40-Admin",
guid="875sasda",
groupBits=16,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
self.superadmin = FakeClient(self.console,
name="God",
exactName="God",
guid="f4qfer654r",
groupBits=128,
team=TEAM_UNKNOWN,
teamId=0,
squad=0)
if status.getBoolean():
self.debug('Playlist Enabled')
return True
else:
self.debug('Playlist Disabled')
return False
#-------------------------------------------------------------------------------------
if __name__ == '__main__':
from b3.fake import fakeConsole
from b3.fake import superadmin
from b3.config import XmlConfigParser
conf = XmlConfigParser()
conf.loadFromString('''
<configuration plugin="poweradmincod7">
<settings name="commands">
<!--
Following command works on RANKED servers only
-->
<set name="pasetmap-setmap">40</set>
<!--
Following commands work both on RANKED and UNRANKED servers
-->
<set name="paplaylist-playlist">40</set>
<set name="pagetplaylists-getplaylists">100</set>
<set name="pasetplaylist-setplaylist">100</set>
<set name="paexcludemaps-excludemaps">100</set>
<set name="paversion">1</set>
