def setUp(self):
with logging_disabled():
# 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 = Iourt42Parser(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.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)
# prepare a few players
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)
class Welcome_functional_test(B3TestCase):
def setUp(self):
B3TestCase.setUp(self)
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.p = WelcomePlugin(self.console, self.conf)
self.joe = FakeClient(self.console, name="Joe", guid="joeguid", groupBits=1, team=b3.TEAM_RED)
self.mike = FakeClient(self.console, name="Mike", guid="mikeguid", groupBits=1, team=b3.TEAM_RED)
self.bill = FakeClient(self.console, name="Bill", guid="billguid", groupBits=1, team=b3.TEAM_RED)
self.superadmin = FakeClient(self.console, name="SuperAdmin", guid="superadminguid", groupBits=128, team=b3.TEAM_RED)
def load_config(self, config_content=None):
"""
load the given config content, or the default config if config_content is None.
"""
if config_content is None:
self.conf.load(b3.getAbsolutePath('@b3/conf/plugin_welcome.ini'))
else:
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
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
def setUp(self):
B3TestCase.setUp(self)
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.p = WelcomePlugin(self.console, self.conf)
self.joe = FakeClient(self.console,
name="Joe",
guid="joeguid",
groupBits=1,
team=b3.TEAM_RED)
self.mike = FakeClient(self.console,
name="Mike",
guid="mikeguid",
groupBits=1,
team=b3.TEAM_RED)
self.bill = FakeClient(self.console,
name="Bill",
guid="billguid",
groupBits=1,
team=b3.TEAM_RED)
self.superadmin = FakeClient(self.console,
name="SuperAdmin",
guid="superadminguid",
groupBits=128,
team=b3.TEAM_RED)
def setUp(self):
B3TestCase.setUp(self)
self.console.gameName = 'f00'
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.conf.loadFromString(
dedent(r"""
[commands]
plugin: superadmin
"""))
self.p = PluginmanagerPlugin(self.console, self.conf)
when(self.console).getPlugin("pluginmanager").thenReturn(
self.adminPlugin)
self.p.onLoadConfig()
self.p.onStartup()
when(self.console.config).get_external_plugins_dir().thenReturn(
b3.getAbsolutePath('@b3\\extplugins'))
# store them also in the console _plugins dict
self.console._plugins['admin'] = self.adminPlugin
self.console._plugins['pluginmanager'] = self.p
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 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 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 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 DuelTestCase(unittest2.TestCase):
def setUp(self):
console_conf = CfgConfigParser()
console_conf.loadFromString(r'''''')
self.console_main_conf = MainConfig(console_conf)
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.console_main_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).getPlugin('admin').thenReturn(self.adminPlugin)
# create our plugin instance
self.p = DuelPlugin(self.console)
self.p.onStartup()
with logging_disabled():
from b3.fake import FakeClient
self.mike = FakeClient(console=self.console, name="Mike", guid="MIKEGUID", groupBits=1)
self.bill = FakeClient(console=self.console, name="Bill", guid="BILLGUID", groupBits=1)
self.anna = FakeClient(console=self.console, name="Anna", guid="ANNAGUID", groupBits=1)
def tearDown(self):
unstub()
def setUp(self):
B3TestCase.setUp(self)
self.console.gameName = 'f00'
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.conf.loadFromString(dedent(r"""
[settings]
update_config_file: no
[commands]
cmdlevel: fulladmin
cmdalias: fulladmin
cmdgrant: superadmin
cmdrevoke: superadmin
cmduse: superadmin
"""))
self.p = CmdmanagerPlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
class ProxyfilterTestCase(unittest2.TestCase):
def setUp(self):
# create a FakeConsole parser
self.parser_conf = MainConfig(CfgConfigParser(allow_no_value=True))
self.parser_conf.loadFromString(r"""""")
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_conf)
# load the admin plugin
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).getPlugin('admin').thenReturn(self.adminPlugin)
when(self.console.config).get_external_plugins_dir().thenReturn(os.path.join(os.getcwd(), '..', '..'))
# patch the Proxyfilter class not to execute
# proxy scans in a multithreaded environment
patch_proxy_filter()
def tearDown(self):
self.console.working = False
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()
def setUp(self):
B3TestCase.setUp(self)
with logging_disabled():
admin_conf = CfgConfigParser()
admin_plugin = AdminPlugin(self.console, admin_conf)
admin_plugin.onLoadConfig()
admin_plugin.onStartup()
when(self.console).getPlugin('admin').thenReturn(admin_plugin)
conf = CfgConfigParser()
conf.loadFromString(dedent(r"""
[commands]
mapstats-stats: 0
testscore-ts: 0
topstats-top: 0
topxp: 0
[settings]
startPoints: 100
resetscore: no
resetxp: no
show_awards: no
show_awards_xp: no
"""))
self.p = StatsPlugin(self.console, conf)
self.p.onLoadConfig()
self.p.onStartup()
self.joe = FakeClient(self.console, name="Joe", guid="joeguid", groupBits=1, team=TEAM_RED)
self.mike = FakeClient(self.console, name="Mike", guid="mikeguid", groupBits=1, team=TEAM_RED)
self.joe.connects(1)
self.mike.connects(2)
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)
# 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)
self.console.screen = Mock()
self.console.time = time.time
self.console.upTime = Mock(return_value=3)
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
def setUp(self):
# create a FakeConsole parser
parser_ini_conf = CfgConfigParser()
parser_ini_conf.loadFromString(r'''''')
self.parser_main_conf = MainConfig(parser_ini_conf)
with logging_disabled():
from tests.fake import FakeConsole
self.console = FakeConsole(self.parser_main_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).getPlugin('admin').thenReturn(self.adminPlugin)
# create our plugin instance
self.p = SpreePlugin(self.console, CfgConfigParser())
with logging_disabled():
from tests.fake import FakeClient
self.mike = FakeClient(console=self.console,
name="Mike",
guid="MIKEGUID",
groupBits=1)
self.bill = FakeClient(console=self.console,
name="Bill",
guid="BILLGUID",
groupBits=1)
def setUp(self):
"""
This method is called before each test.
It is meant to set up the SUT (System Under Test) in a manner that will ease the testing of its features.
"""
with logging_disabled():
# The B3TestCase class provides us a working B3 environment that does not require any database connexion.
# The B3 console is then accessible with self.console
B3TestCase.setUp(self)
# set additional B3 console stuff that will be used by the XLRstats plugin
self.console.gameName = "MyGame"
self.parser_conf.add_section('b3')
self.parser_conf.set('b3', 'time_zone', 'GMT')
# we make our own AdminPlugin and make sure it is the one return in any case
self.adminPlugin = AdminPlugin(self.console, DEFAULT_ADMIN_CONFIG_FILE)
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
# We need a config for the Xlrstats plugin
self.conf = CfgConfigParser() # It is an empty config but we can fill it up later
# Now we create an instance of the SUT (System Under Test) which is the XlrstatsPlugin
self.p = XlrstatsPlugin(self.console, self.conf)
when(self.console).getPlugin("xlrstats").thenReturn(self.p)
# create a client object to represent the game server
with patch("b3.clients.Clients.authorizeClients"): # we patch authorizeClients or it will spawn a thread
# with a 5 second timer
self.console.clients.newClient(-1, name="WORLD", guid="WORLD", hide=True)
class PluginmanagerTestCase(B3TestCase):
def setUp(self):
B3TestCase.setUp(self)
self.console.gameName = 'f00'
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.conf.loadFromString(dedent(r"""
[commands]
plugin: superadmin
"""))
self.p = PluginmanagerPlugin(self.console, self.conf)
when(self.console).getPlugin("pluginmanager").thenReturn(self.adminPlugin)
self.p.onLoadConfig()
self.p.onStartup()
when(self.console.config).get_external_plugins_dir().thenReturn(b3.getAbsolutePath('@b3\\extplugins'))
# store them also in the console _plugins dict
self.console._plugins['admin'] = self.adminPlugin
self.console._plugins['pluginmanager'] = self.p
def tearDown(self):
self.console._plugins.clear()
B3TestCase.tearDown(self)
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 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
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
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
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)
# 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._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()
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 Admin_functional_test(B3TestCase):
""" tests from a class inheriting from Admin_functional_test must call self.init() """
def setUp(self):
B3TestCase.setUp(self)
self.conf = CfgConfigParser()
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:
self.conf.load(b3.getAbsolutePath("@b3/conf/plugin_admin.ini"))
else:
self.conf.loadFromString(config_content)
self.p._commands = {}
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)
def setUp(self):
B3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.setXml("""
<configuration plugin="admin">
</configuration>
""")
self.p = AdminPlugin(b3.console, self.conf)
class CountryFilterTestCase(unittest2.TestCase):
def setUp(self):
# create a FakeConsole parser
parser_ini_conf = CfgConfigParser()
parser_ini_conf.loadFromString(r'''''')
self.parser_main_conf = MainConfig(parser_ini_conf)
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_main_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).getPlugin('admin').thenReturn(self.adminPlugin)
# simulate geolocation plugin registering events
self.console.createEvent('EVT_CLIENT_GEOLOCATION_SUCCESS',
'Event client geolocation success')
self.console.screen = Mock()
self.console.time = time.time
self.console.upTime = Mock(return_value=1000)
self.console.cron.stop()
# create our plugin instance
self.p = CountryfilterPlugin(self.console, CfgConfigParser())
with logging_disabled():
from b3.fake import FakeClient
self.mike = FakeClient(console=self.console,
name="Mike",
guid="MIKEGUID",
ip='1.2.3.4',
groupBits=0)
self.bill = FakeClient(console=self.console,
name="Bill",
guid="BILLGUID",
ip='2.3.4.5',
groupBits=0)
self.mike.location = LOCATION_MIKE
self.bill.location = LOCATION_BILL
def tearDown(self):
unstub()
def init(self, config_content):
"""
Initialize the plugin using the given configuration file content
"""
self.p.config.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
class MapcycleTestCase(unittest2.TestCase):
@classmethod
def setUpClass(cls):
with logging_disabled():
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 Iourt42 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(dedent(r"""
<configuration>
<settings name="server">
<set name="game_log"></set>
</settings>
</configuration>
"""))
self.console = Iourt42Parser(self.parser_conf)
# initialize some fixed cvars which will be used by both the plugin and the iourt42 parser
when(self.console).getCvar('auth').thenReturn(Cvar('auth', value='0'))
when(self.console).getCvar('fs_basepath').thenReturn(Cvar('g_maxGameClients', value='/fake/basepath'))
when(self.console).getCvar('fs_homepath').thenReturn(Cvar('sv_maxclients', value='/fake/homepath'))
when(self.console).getCvar('fs_game').thenReturn(Cvar('fs_game', value='q3ut4'))
when(self.console).getCvar('gamename').thenReturn(Cvar('gamename', value='q3urt42'))
# start the parser
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
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)
# force fake mapname here so Mapcycle Plugin will
# not catch useless EVT_GAME_MAP_CHANGE
self.console.game.mapName = 'ut4_casa'
self.conf = XmlConfigParser()
self.conf.loadFromString(dedent(MAPCYCLE_PLUGIN_CONFIG))
# patch the mapcycle plugin for testing purpose
patch_mapcycle_plugin()
self.p = MapcyclePlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
def tearDown(self):
self.console.working = False
class AdvTestCase(B3TestCase):
"""
Ease test cases that need an working B3 console and need to control the ADV plugin config
"""
def setUp(self):
self.log = logging.getLogger('output')
self.log.propagate = False
B3TestCase.setUp(self)
self.adminPluginConf = CfgConfigParser()
self.adminPluginConf.load(ADMIN_CONFIG_FILE)
self.adminPlugin = AdminPlugin(self.console, self.adminPluginConf)
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.console.startup()
self.log.propagate = True
global ADV_CONFIG_CONTENT, ADV_CONFIG_FILE, ADMIN_CONFIG_FILE, timer_patcher
if os.path.exists(ADV_CONFIG_FILE):
with open(ADV_CONFIG_FILE, 'r') as f:
ADV_CONFIG_CONTENT = f.read()
timer_patcher = patch('threading.Timer')
timer_patcher.start()
def tearDown(self):
B3TestCase.tearDown(self)
timer_patcher.stop()
unstub()
def init_plugin(self, config_content=None):
conf = None
if config_content:
conf = XmlConfigParser()
conf.setXml(config_content)
elif ADV_CONFIG_CONTENT:
conf = XmlConfigParser()
conf.setXml(ADV_CONFIG_CONTENT)
else:
unittest.skip("cannot get default plugin config file at %s" %
ADV_CONFIG_FILE)
self.p = AdvPlugin(self.console, conf)
self.p.save = Mock()
self.conf = self.p.config
self.log.setLevel(logging.DEBUG)
self.log.info(
"============================= Adv plugin: loading config ============================"
)
self.p.onLoadConfig()
self.log.info(
"============================= Adv plugin: starting ================================="
)
self.p.onStartup()
class Iourt41TestCase(unittest.TestCase):
"""
Test case that is suitable for testing Iourt41 parser specific features
"""
@classmethod
def setUpClass(cls):
with logging_disabled():
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):
with logging_disabled():
# 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.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.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)
# prepare a few players
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
# sys.stdout.write("\tactive threads count : %s " % threading.activeCount())
# sys.stderr.write("%s\n" % threading.enumerate())
def init_default_cvar(self):
when(self.console).getCvar('timelimit').thenReturn(Cvar('timelimit', value=20))
when(self.console).getCvar('g_maxGameClients').thenReturn(Cvar('g_maxGameClients', value=16))
when(self.console).getCvar('sv_maxclients').thenReturn(Cvar('sv_maxclients', value=16))
when(self.console).getCvar('sv_privateClients').thenReturn(Cvar('sv_privateClients', value=0))
when(self.console).getCvar('g_allowvote').thenReturn(Cvar('g_allowvote', value=0))
when(self.console).getCvar('g_gear').thenReturn(Cvar('g_gear', value=''))
class Admin_TestCase(B3TestCase):
def setUp(self):
B3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.load(ADMIN_CONFIG_FILE)
self.p = AdminPlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
def setUp(self):
# create a Iourt42 parser
parser_conf = XmlConfigParser()
parser_conf.loadFromString(dedent(r"""
<configuration>
<settings name="server">
<set name="game_log"></set>
</settings>
</configuration>
"""))
self.parser_conf = MainConfig(parser_conf)
self.console = Iourt42Parser(self.parser_conf)
# initialize some fixed cvars which will be used by both the plugin and the iourt42 parser
when(self.console).getCvar('auth').thenReturn(Cvar('auth', value='0'))
when(self.console).getCvar('fs_basepath').thenReturn(Cvar('fs_basepath', value='/fake/basepath'))
when(self.console).getCvar('fs_homepath').thenReturn(Cvar('fs_homepath', value='/fake/homepath'))
when(self.console).getCvar('fs_game').thenReturn(Cvar('fs_game', value='q3ut4'))
when(self.console).getCvar('gamename').thenReturn(Cvar('gamename', value='q3urt42'))
# start the parser
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
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)
self.conf = CfgConfigParser()
self.conf.loadFromString(dedent(r"""
[settings]
demorecord: no
skipstandardmaps: yes
minleveldelete: senioradmin
[commands]
delrecord: guest
maprecord: guest
mapinfo: guest
record: guest
setway: senioradmin
topruns: guest
map: fulladmin
maps: user
setnextmap: admin
"""))
self.p = JumperPlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
# load fixed json data (do not contact urtjumpers api for testing)
when(self.p).getMapsDataFromApi().thenReturn(json.loads(MAPDATA_JSON))
def setUp(self):
from b3.fake import fakeConsole
B3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.setXml("""
<configuration plugin="admin">
</configuration>
""")
self.p = AdminPlugin(fakeConsole, self.conf)
def setUp(self):
# create a Iourt42 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(
"""<configuration><settings name="server"><set name="game_log"></set></settings></configuration>"""
)
self.console = Iourt42Parser(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._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)
# prepare a few players
self.joe = FakeClient(self.console,
name="Joe",
guid="Joe_guid",
groupBits=1,
team=TEAM_UNKNOWN)
self.simon = FakeClient(self.console,
name="Simon",
guid="Simon_guid",
groupBits=0,
team=TEAM_UNKNOWN)
self.reg = FakeClient(self.console,
name="Reg",
guid="Reg_guid",
groupBits=4,
team=TEAM_UNKNOWN)
self.moderator = FakeClient(self.console,
name="Moderator",
guid="Moderator_guid",
groupBits=8,
team=TEAM_UNKNOWN)
self.admin = FakeClient(self.console,
name="Level-40-Admin",
guid="Admin_guid",
groupBits=16,
team=TEAM_UNKNOWN)
self.superadmin = FakeClient(self.console,
name="Superadmin",
guid="Superadmin_guid",
groupBits=128,
team=TEAM_UNKNOWN)
logging.getLogger('output').setLevel(logging.DEBUG)
class test_functional(unittest.TestCase):
@classmethod
def setUpClass(cls):
from b3.fake import FakeConsole
RavagedParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# RavagedParser -> 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 = RavagedParser(self.conf)
self.parser.output = Mock()
self.parser.output.write = Mock()
ADMIN_CONFIG = XmlConfigParser()
ADMIN_CONFIG.load(ADMIN_CONFIG_FILE)
self.adminPlugin = AdminPlugin(self.parser, ADMIN_CONFIG)
when(self.parser).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.parser.startup()
def tearDown(self):
if hasattr(self, "parser"):
del self.parser.clients
self.parser.working = False
def test_map(self):
# GIVEN
when(self.parser.output).write("getmaplist false").thenReturn(u"""0 CTR_Bridge
1 CTR_Canyon
2 CTR_Derelict
3 CTR_IceBreaker
4 CTR_Liberty
5 CTR_Rooftop
6 Thrust_Bridge
7 Thrust_Canyon
8 Thrust_Chasm
9 Thrust_IceBreaker
10 Thrust_Liberty
11 Thrust_Oilrig
12 Thrust_Rooftop
""".encode('UTF-8'))
admin = FakeClient(console=self.parser, name="admin", guid="guid_admin", groupBits=128)
admin.connects("guid_admin")
# WHEN
with patch.object(self.parser.output, 'write', wraps=self.parser.output.write) as write_mock:
admin.says("!map chasm")
# THEN
write_mock.assert_has_calls([call("addmap Thrust_Chasm 1"), call("nextmap")])
class Iourt42TestCase(unittest.TestCase):
"""
Test case that is suitable for testing Iourt41 parser specific features
"""
@classmethod
def setUpClass(cls):
with logging_disabled():
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):
with logging_disabled():
# 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 = Iourt42Parser(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.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)
# prepare a few players
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
# sys.stdout.write("\tactive threads count : %s " % threading.activeCount())
# sys.stderr.write("%s\n" % threading.enumerate())
def init_default_cvar(self):
when(self.console).getCvar('timelimit').thenReturn(Cvar('timelimit', value=20))
when(self.console).getCvar('g_maxGameClients').thenReturn(Cvar('g_maxGameClients', value=16))
when(self.console).getCvar('sv_maxclients').thenReturn(Cvar('sv_maxclients', value=16))
when(self.console).getCvar('sv_privateClients').thenReturn(Cvar('sv_privateClients', value=0))
when(self.console).getCvar('g_allowvote').thenReturn(Cvar('g_allowvote', value=0))
when(self.console).getCvar('g_gear').thenReturn(Cvar('g_gear', value=''))
class SpreeTestCase(unittest2.TestCase):
def setUp(self):
# create a FakeConsole parser
parser_ini_conf = CfgConfigParser()
parser_ini_conf.loadFromString(r'''''')
self.parser_main_conf = MainConfig(parser_ini_conf)
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_main_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).getPlugin('admin').thenReturn(self.adminPlugin)
# create our plugin instance
self.p = SpreePlugin(self.console, CfgConfigParser())
with logging_disabled():
from b3.fake import FakeClient
self.mike = FakeClient(console=self.console, name="Mike", guid="MIKEGUID", groupBits=1)
self.bill = FakeClient(console=self.console, name="Bill", guid="BILLGUID", groupBits=1)
def tearDown(self):
unstub()
def init(self, config_content=None):
"""
Initialize the plugin using the given configuration file content
"""
if not config_content:
config_content = dedent(r"""
[settings]
reset_spree: yes
[killingspree_messages]
5: %player% is on a killing spree (5 kills in a row) # %player% stopped the spree of %victim%
10: %player% is on fire! (10 kills in a row) # %player% iced %victim%
[loosingspree_messages]
12: Keep it up %player%, it will come eventually # You're back in business %player%
[commands]
spree: user
""")
self.p.config.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
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.ERROR)
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 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.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
# when starting the PoweradminurtPlugin expects the game server to provide a few cvar values
when(self.console).getCvar('timelimit').thenReturn(Cvar('timelimit', value=20))
when(self.console).getCvar('g_maxGameClients').thenReturn(Cvar('g_maxGameClients', value=16))
when(self.console).getCvar('sv_maxclients').thenReturn(Cvar('sv_maxclients', value=16))
when(self.console).getCvar('sv_privateClients').thenReturn(Cvar('sv_privateClients', value=0))
when(self.console).getCvar('g_allowvote').thenReturn(Cvar('g_allowvote', value=0))
# prepare a few players
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
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)
from b3.parsers.frostbite2.abstractParser import AbstractParser
from b3.fake import FakeConsole
AbstractParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# Bf3Parser -> AbstractParser -> FakeConsole -> Parser
# Update method says of FakeClient so it let the Bf3Parser fire the SAY event
def says(self, msg):
print "\n%s says \"%s\"" % (self.name, msg)
self.console.queueEvent(self.console.OnPlayerChat(action=None, data=(self.cid, msg, 'all')))
FakeClient.says = says
def setUp(self):
# create a BF3 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(r"""<configuration/>""")
self.console = Bf3Parser(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.onLoadConfig()
self.adminPlugin.onStartup()
#when(self.console).time().thenReturn(time.time())
# 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", 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
class UrtauthTestCase(unittest2.TestCase):
@classmethod
def setUpClass(cls):
with logging_disabled():
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 Iourt42 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(dedent(r"""
<configuration>
<settings name="server">
<set name="game_log"></set>
</settings>
</configuration>
"""))
self.console = Iourt42Parser(self.parser_conf)
when(self.console).getCvar('auth').thenReturn(Cvar('auth', value='1'))
when(self.console).getCvar('fs_basepath').thenReturn(Cvar('fs_basepath', value='/fake/basepath'))
when(self.console).getCvar('fs_homepath').thenReturn(Cvar('fs_homepath', value='/fake/homepath'))
when(self.console).getCvar('fs_game').thenReturn(Cvar('fs_game', value='q3ut4'))
when(self.console).getCvar('gamename').thenReturn(Cvar('gamename', value='q3urt42'))
# start the parser
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
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)
self.conf = CfgConfigParser()
self.conf.loadFromString(dedent(r"""
[settings]
maxlevel: reg
reason: ^7you need an ^1auth ^7account to play here
"""))
self.p = UrtauthPlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
def tearDown(self):
self.console.working = False
def setUp(self):
self.parser_conf = MainConfig(CfgConfigParser(allow_no_value=True))
self.parser_conf.loadFromString(dedent(r""""""))
self.console = FakeConsole(self.parser_conf)
self.console.gameName = 'f00'
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
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 AdvTestCase(B3TestCase):
"""
Ease test cases that need an working B3 console and need to control the ADV plugin config
"""
def setUp(self):
self.log = logging.getLogger('output')
self.log.propagate = False
B3TestCase.setUp(self)
global ADV_CONFIG_CONTENT, ADV_CONFIG_FILE, ADMIN_CONFIG_FILE, timer_patcher
if os.path.exists(ADV_CONFIG_FILE):
with open(ADV_CONFIG_FILE, 'r') as f:
ADV_CONFIG_CONTENT = f.read()
self.adminPluginConf = CfgConfigParser()
self.adminPluginConf.load(ADMIN_CONFIG_FILE)
self.adminPlugin = AdminPlugin(self.console, self.adminPluginConf)
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.console.startup()
self.log.propagate = True
timer_patcher = patch('threading.Timer')
timer_patcher.start()
def tearDown(self):
B3TestCase.tearDown(self)
timer_patcher.stop()
unstub()
def init_plugin(self, config_content=None):
conf = None
if config_content:
conf = XmlConfigParser()
conf.setXml(config_content)
elif ADV_CONFIG_CONTENT:
conf = XmlConfigParser()
conf.setXml(ADV_CONFIG_CONTENT)
else:
unittest.skip("cannot get default plugin config file at %s" % ADV_CONFIG_FILE)
self.p = AdvPlugin(self.console, conf)
self.p.save = Mock()
self.conf = self.p.config
self.log.setLevel(logging.DEBUG)
self.log.info("============================= Adv plugin: loading config ============================")
self.p.onLoadConfig()
self.log.info("============================= Adv plugin: starting =================================")
self.p.onStartup()
class ServermonitorTestCase(TestCase):
"""
TestCase suitable for testing the ServermonitorPlugin class
"""
def setUp(self):
# less logging
self.logger = logging.getLogger('output')
self.logger.setLevel(logging.ERROR)
self.logger.propagate = False
from b3.fake import FakeConsole, FakeClient
# create a Fake parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(
"""<configuration><settings name="server"><set name="game_log"></set></settings></configuration>"""
)
self.console = FakeConsole(self.parser_conf)
self.console.startup()
# load the admin plugin
# 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.onLoadConfig()
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)
# load our plugin
self.conf = CfgConfigParser()
self.p = ServermonitorPlugin(self.console, self.conf)
self.superadmin = FakeClient(self.console,
name="Superadmin",
guid="Superadmin_guid",
groupBits=128)
self.logger.propagate = True
def init_plugin(self, config_content):
self.logger.setLevel(VERBOSE)
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
class NickregTestCase(unittest2.TestCase):
def setUp(self):
# 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).getPlugin('admin').thenReturn(self.adminPlugin)
self.conf = CfgConfigParser()
self.conf.loadFromString(
dedent("""
[settings]
min_level: mod
min_level_global_manage: admin
max_nicks: 3
interval: 30
"""))
self.p = NickregPlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
with logging_disabled():
from b3.fake import FakeClient
self.senioradmin = FakeClient(console=self.console,
name="SeniorAdmin",
guid="SENIORADMIN",
groupBits=64)
self.admin = FakeClient(console=self.console,
name="Admin",
guid="ADMIN",
groupBits=16)
self.guest = FakeClient(console=self.console,
name="Guest",
guid="GUEST",
groupBits=0)
self.admin.connects("1")
self.guest.connects("2")
self.senioradmin.connects("3")
def tearDown(self):
pass
class Admin_functional_test(B3TestCase):
def setUp(self):
B3TestCase.setUp(self)
self.conf = XmlConfigParser()
self.conf.load(ADMIN_CONFIG_FILE)
self.p = AdminPlugin(self.console, self.conf)
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 IpbanTestCase(unittest2.TestCase):
def setUp(self):
self.parser_conf = MainConfig(CfgConfigParser(allow_no_value=True))
self.parser_conf.loadFromString(dedent(r""""""))
self.console = FakeConsole(self.parser_conf)
self.console.gameName = 'f00'
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
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()
def setUp(self):
self.log = logging.getLogger('output')
self.log.propagate = False
B3TestCase.setUp(self)
self.adminPlugin = AdminPlugin(self.console, ADMIN_CONFIG)
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.console.startup()
self.log.propagate = True
class XlrstatsTestCase(B3TestCase):
def setUp(self):
"""
This method is called before each test.
It is meant to set up the SUT (System Under Test) in a manner that will ease the testing of its features.
"""
with logging_disabled():
# The B3TestCase class provides us a working B3 environment that does not require any database connexion.
# The B3 console is then accessible with self.console
B3TestCase.setUp(self)
# set additional B3 console stuff that will be used by the XLRstats plugin
self.console.gameName = "MyGame"
self.parser_conf.add_section('b3')
self.parser_conf.set('b3', 'time_zone', 'GMT')
# we make our own AdminPlugin and make sure it is the one return in any case
self.adminPlugin = AdminPlugin(self.console, DEFAULT_ADMIN_CONFIG_FILE)
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
# We need a config for the Xlrstats plugin
self.conf = CfgConfigParser() # It is an empty config but we can fill it up later
# Now we create an instance of the SUT (System Under Test) which is the XlrstatsPlugin
self.p = XlrstatsPlugin(self.console, self.conf)
when(self.console).getPlugin("xlrstats").thenReturn(self.p)
# create a client object to represent the game server
with patch("b3.clients.Clients.authorizeClients"): # we patch authorizeClients or it will spawn a thread
# with a 5 second timer
self.console.clients.newClient(-1, name="WORLD", guid="WORLD", hide=True)
def init(self, config_content=None):
"""
Load the config and starts the xlrstats plugin.
If no config_content is provided, use the default config file
:param config_content: optional XLRstats config
:type config_content: str
"""
if config_content is None:
self.conf.load(DEFAULT_XLRSTATS_CONFIG_FILE)
else:
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.minlevel = 1 # tests in this module assume unregistered players aren't considered by Xlrstats
self.p.onStartup()
class Cmdmanager_TestCase(B3TestCase):
def setUp(self):
B3TestCase.setUp(self)
self.console.gameName = 'f00'
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.conf.loadFromString(
dedent(r"""
[settings]
update_config_file: no
[commands]
cmdlevel: fulladmin
cmdalias: fulladmin
cmdgrant: superadmin
cmdrevoke: superadmin
cmduse: superadmin
"""))
self.p = CmdmanagerPlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
def assert_cmd_groups(self, cmd_name, groups):
"""
Assert a command has the given authorized groups set correctly.
:param cmd_name: str name of a command
:param groups: str minimum group required to run the command or group range
"""
cmd = self.adminPlugin._commands[cmd_name]
self.assertIsNotNone(cmd, "could not find command %r" % cmd_name)
self.assertEqual(groups, self.p.get_command_level_string(cmd))
def assert_cmd_alias(self, cmd_name, alias_name):
"""
Assert a command has the given alias.
:param cmd_name: str command name
:param alias_name: str expected alias name, or None
"""
cmd = self.adminPlugin._commands[cmd_name]
self.assertIsNotNone(cmd, "could not find command %r" % cmd_name)
self.assertEqual(alias_name if alias_name is not None else '',
cmd.alias)
class CountryFilterTestCase(unittest2.TestCase):
def setUp(self):
# create a FakeConsole parser
parser_ini_conf = CfgConfigParser()
parser_ini_conf.loadFromString(r'''''')
self.parser_main_conf = MainConfig(parser_ini_conf)
with logging_disabled():
from b3.fake import FakeConsole
self.console = FakeConsole(self.parser_main_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).getPlugin('admin').thenReturn(self.adminPlugin)
# simulate geolocation plugin registering events
self.console.createEvent('EVT_CLIENT_GEOLOCATION_SUCCESS', 'Event client geolocation success')
self.console.screen = Mock()
self.console.time = time.time
self.console.upTime = Mock(return_value=1000)
self.console.cron.stop()
# create our plugin instance
self.p = CountryfilterPlugin(self.console, CfgConfigParser())
with logging_disabled():
from b3.fake import FakeClient
self.mike = FakeClient(console=self.console, name="Mike", guid="MIKEGUID", ip='1.2.3.4', groupBits=0)
self.bill = FakeClient(console=self.console, name="Bill", guid="BILLGUID", ip='2.3.4.5', groupBits=0)
self.mike.location = LOCATION_MIKE
self.bill.location = LOCATION_BILL
def tearDown(self):
unstub()
def init(self, config_content):
"""
Initialize the plugin using the given configuration file content
"""
self.p.config.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()
class CallvoteTestCase(unittest2.TestCase):
@classmethod
def setUpClass(cls):
with logging_disabled():
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 Iourt42 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString(
dedent(r"""
<configuration>
<settings name="server">
<set name="game_log"></set>
</settings>
</configuration>
"""))
self.console = Iourt42Parser(self.parser_conf)
# initialize some fixed cvars which will be used by both the plugin and the iourt42 parser
when(self.console).getCvar('auth').thenReturn(Cvar('auth', value='0'))
when(self.console).getCvar('fs_basepath').thenReturn(
Cvar('fs_basepath', value='/fake/basepath'))
when(self.console).getCvar('fs_homepath').thenReturn(
Cvar('fs_homepath', value='/fake/homepath'))
when(self.console).getCvar('fs_game').thenReturn(
Cvar('fs_game', value='q3ut4'))
when(self.console).getCvar('gamename').thenReturn(
Cvar('gamename', value='q3urt42'))
# start the parser
self.console.startup()
with logging_disabled():
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
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 Iourt42TestCase(unittest.TestCase):
"""
Test case that is suitable for testing Iourt41 parser specific features
"""
@classmethod
def setUpClass(cls):
# less logging
logging.getLogger('output').setLevel(logging.ERROR)
from b3.parsers.q3a.abstractParser import AbstractParser
from b3.fake import FakeConsole
AbstractParser.__bases__ = (FakeConsole,)
# Now parser inheritance hierarchy is :
# Iourt42Parser -> abstractParser -> FakeConsole -> Parser
def setUp(self):
# create a Iourt42 parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""<configuration><settings name="server"><set name="game_log"></set></settings></configuration>""")
self.console = Iourt42Parser(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._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)
# prepare a few players
self.joe = FakeClient(self.console, name="Joe", guid="Joe_guid", groupBits=1, team=TEAM_UNKNOWN)
self.simon = FakeClient(self.console, name="Simon", guid="Simon_guid", groupBits=0, team=TEAM_UNKNOWN)
self.reg = FakeClient(self.console, name="Reg", guid="Reg_guid", groupBits=4, team=TEAM_UNKNOWN)
self.moderator = FakeClient(self.console, name="Moderator", guid="Moderator_guid", groupBits=8, team=TEAM_UNKNOWN)
self.admin = FakeClient(self.console, name="Level-40-Admin", guid="Admin_guid", groupBits=16, team=TEAM_UNKNOWN)
self.superadmin = FakeClient(self.console, name="Superadmin", guid="Superadmin_guid", groupBits=128, team=TEAM_UNKNOWN)
logging.getLogger('output').setLevel(logging.DEBUG)
def tearDown(self):
self.console.working = False
self.adminPlugin = None
class Test_plugin(SpamcontrolTestCase):
def setUp(self):
SpamcontrolTestCase.setUp(self)
self.adminPlugin = AdminPlugin(self.console,
'@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
with open(b3.getAbsolutePath(
'@b3/conf/plugin_spamcontrol.ini')) as default_conf:
self.init_plugin(default_conf.read())
self.joe = FakeClient(self.console,
name="Joe",
guid="zaerezarezar",
groupBits=1)
self.joe.connects("1")
self.superadmin = FakeClient(self.console,
name="Superadmin",
guid="superadmin_guid",
groupBits=128)
self.superadmin.connects("2")
def assertSpaminsPoints(self, client, points):
actual = client.var(self.p, 'spamins', 0).value
self.assertEqual(
points, actual,
"expecting %s to have %s spamins points" % (client.name, points))
def test_say(self):
when(self.p).getTime().thenReturn(0).thenReturn(1).thenReturn(
20).thenReturn(120)
self.assertSpaminsPoints(self.joe, 0)
self.joe.says("doh") # 0s
self.assertSpaminsPoints(self.joe, 2)
self.joe.says("foo") # 1s
self.assertSpaminsPoints(self.joe, 4)
self.joe.says("bar") # 20s
self.assertSpaminsPoints(self.joe, 3)
self.joe.says("hi") # 120s
self.assertSpaminsPoints(self.joe, 0)
def console():
with logging_disabled():
from b3.fake import FakeConsole
fake_console = FakeConsole('@b3/conf/b3.distribution.xml')
# load the admin plugin
with logging_disabled():
admin_plugin = AdminPlugin(fake_console, '@b3/conf/plugin_admin.ini')
admin_plugin._commands = {} # work around known bug in the Admin plugin which makes the _command property shared between all instances
admin_plugin.onStartup()
# make sure the admin plugin obtained by other plugins is our admin plugin
when(fake_console).getPlugin('admin').thenReturn(admin_plugin)
return fake_console
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()
class Cmdmanager_TestCase(B3TestCase):
def setUp(self):
B3TestCase.setUp(self)
self.console.gameName = 'f00'
self.adminPlugin = AdminPlugin(self.console, '@b3/conf/plugin_admin.ini')
when(self.console).getPlugin("admin").thenReturn(self.adminPlugin)
self.adminPlugin.onLoadConfig()
self.adminPlugin.onStartup()
self.conf = CfgConfigParser()
self.conf.loadFromString(dedent(r"""
[settings]
update_config_file: no
[commands]
cmdlevel: fulladmin
cmdalias: fulladmin
cmdgrant: superadmin
cmdrevoke: superadmin
cmduse: superadmin
"""))
self.p = CmdmanagerPlugin(self.console, self.conf)
self.p.onLoadConfig()
self.p.onStartup()
def assert_cmd_groups(self, cmd_name, groups):
"""
Assert a command has the given authorized groups set correctly.
:param cmd_name: str name of a command
:param groups: str minimum group required to run the command or group range
"""
cmd = self.adminPlugin._commands[cmd_name]
self.assertIsNotNone(cmd, "could not find command %r" % cmd_name)
self.assertEqual(groups, self.p.get_command_level_string(cmd))
def assert_cmd_alias(self, cmd_name, alias_name):
"""
Assert a command has the given alias.
:param cmd_name: str command name
:param alias_name: str expected alias name, or None
"""
cmd = self.adminPlugin._commands[cmd_name]
self.assertIsNotNone(cmd, "could not find command %r" % cmd_name)
self.assertEqual(alias_name if alias_name is not None else '', cmd.alias)
class ServermonitorTestCase(TestCase):
"""
TestCase suitable for testing the ServermonitorPlugin class
"""
def setUp(self):
# less logging
self.logger = logging.getLogger('output')
self.logger.setLevel(logging.ERROR)
self.logger.propagate = False
from b3.fake import FakeConsole, FakeClient
# create a Fake parser
self.parser_conf = XmlConfigParser()
self.parser_conf.loadFromString("""<configuration><settings name="server"><set name="game_log"></set></settings></configuration>""")
self.console = FakeConsole(self.parser_conf)
self.console.startup()
# load the admin plugin
# 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.onLoadConfig()
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)
# load our plugin
self.conf = CfgConfigParser()
self.p = ServermonitorPlugin(self.console, self.conf)
self.superadmin = FakeClient(self.console, name="Superadmin", guid="Superadmin_guid", groupBits=128)
self.logger.propagate = True
def init_plugin(self, config_content):
self.logger.setLevel(VERBOSE)
self.conf.loadFromString(config_content)
self.p.onLoadConfig()
self.p.onStartup()