def test02_AlternatePokerAuth(self):
"""test02_AlternatePokerAuth
Test Poker auth : get_auth_instance alternate PokerAuth"""
db = None
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_alternate_xml)
auth = pokerauth.get_auth_instance(db, None, settings)
def test07_multipleRowsInVersionTable(self):
"""Test for when the database already exists"""
import MySQLdb
from pokernetwork.pokerdatabase import ExceptionUpgradeFailed
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml, len(settings_xml))
settings.header = settings.doc.xpathNewContext()
self.settings = settings
parameters = settings.headerGetProperties("/server/database")[0]
self.db = pokerdatabase.PokerDatabase(self.settings)
self.db.db.query("DROP TABLE IF EXISTS server;")
self.db.db.query(
"""CREATE TABLE server (version VARCHAR(16) NOT NULL) ENGINE=InnoDB CHARSET=utf8;"""
)
self.db.db.query("""INSERT INTO server (version) VALUES ("1.1.0");""")
self.db.db.query("""INSERT INTO server (version) VALUES ("1.2.0");""")
try:
self.db.setVersionInDatabase("1.3.0")
except ExceptionUpgradeFailed, euf: # handle trouble
self.assertEquals(
euf.args[0],
"UPDATE server SET version = '1.3.0': changed 2 rows, expected one or zero"
)
def test10_persistSessionExplain(self):
"""
the session expires after persistSession, unless there are games in explain
"""
settings_xml = """<?xml version="1.0" encoding="UTF-8"?>
<server verbose="6">
<resthost host="HOST" port="7777" path="PATH" />
</server>"""
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_xml)
service = PokerServiceMockup()
site = pokersite.PokerSite(settings, pokersite.PokerResource(service))
site.memcache = pokermemcache.memcache.Client([])
session = self.site.makeSession('uid', 'auth', False)
session.avatar.tables = []
session.avatar.setExplain(PacketPokerExplain.ALL)
session.avatar.explain.games.games[1] = 'table'
self.assertEquals(True, site.persistSession(session))
self.assertEquals(False, session.expired)
self.assertEquals(('HOST', 7777, 'PATH'), site.memcache.get('uid'))
session.avatar.explain.games.games = {}
self.assertEquals(False, site.persistSession(session))
self.assertEquals(True, session.expired)
self.assertEquals(('HOST', 7777, 'PATH'), site.memcache.get('uid'))
session = self.site.makeSession('uid', 'auth', False)
session.avatar.explain = None
self.assertEquals(False, site.persistSession(session))
self.assertEquals(True, session.expired)
self.assertEquals(('HOST', 7777, 'PATH'), site.memcache.get('uid'))
def test01_Init(self):
"""test01_Init
Test Poker auth : get_auth_instance"""
db = None
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_xml)
auth = pokerauth.get_auth_instance(db, None, settings)
def tearDown(self):
try:
self.db.close()
except:
pass
try:
import MySQLdb
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml,
len(settings_xml))
settings.header = settings.doc.xpathNewContext()
parameters = settings.headerGetProperties("/server/database")[0]
db = MySQLdb.connect(host = parameters["host"],
port = int(parameters.get("port", '3306')),
user = parameters["root_user"],
passwd = parameters["root_password"],
db = 'mysql')
try:
db.query("REVOKE ALL PRIVILEGES, GRANT OPTION FROM '%s'" % parameters['user'])
db.query("drop user '%s'" % parameters['user'])
except:
db.query("delete from user where user = '******'" % parameters['user'])
db.query("FLUSH PRIVILEGES")
db.close()
except Exception, e:
print e
assert("Unable to delete the user, " + parameters["user"] + "; some tests will fail incorrectly.")
def setUp(self):
self.destroyDb()
self.settings = pokernetworkconfig.Config([])
self.settings.doc = libxml2.parseMemory(settings_xml,
len(settings_xml))
self.settings.header = self.settings.doc.xpathNewContext()
self.db = PokerDatabase(self.settings)
def test01_Init(self):
"""test01_Init
Test Poker auth : get_auth_instance"""
db = None
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml, len(settings_xml))
settings.header = settings.doc.xpathNewContext()
auth = pokerauth.get_auth_instance(db, settings)
def initServer(self):
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_xml_server)
self.server_service = pokerservice.PokerService(settings)
self.server_service.disconnectAll = lambda: True
self.server_service.startService()
self.server_site = pokersite.PokerSite(settings, pokerservice.PokerRestTree(self.server_service))
self.server_port = reactor.listenTCP(19481, self.server_site, interface="127.0.0.1")
def setUp(self):
testclock._seconds_reset()
self.destroyDb()
self.settings = settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml, len(settings_xml))
settings.header = settings.doc.xpathNewContext()
self.db = pokerdatabase.PokerDatabase(settings)
self.service = pokerservice.PokerService(settings)
self.default_money = 10000000
def test05_missingRootUser(self):
self.settings = pokernetworkconfig.Config([])
self.settings.loadFromString(settings_missing_root_users_xml)
try:
self.db = pokerdatabase.PokerDatabase(self.settings)
assert False, "Root user information was missing so this line should not be reached."
except MySQLdb.OperationalError, oe: # handle trouble
self.assertEquals(oe.args[1], "Unknown database 'pokernetworktest'")
self.assertEquals(oe.args[0], 1049)
def setUp(self):
testclock._seconds_reset()
random.seed(1)
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml, len(settings_xml))
settings.header = settings.doc.xpathNewContext()
self.service = MockService(settings)
self.clients = {}
self.tourney = None
def makeService(configuration):
settings = pokernetworkconfig.Config([''])
settings.load(configuration)
PokerBotFactory.string_generator = StringGenerator(settings.headerGet("/settings/@name_prefix"))
PokerBot.note_generator = NoteGenerator(settings.headerGet("/settings/currency"))
( host, port ) = split(settings.headerGet("/settings/servers"), ":")
port = int(port)
services = Bots()
services.setSettings(settings)
def bot_serial_generator():
serial = 0
while True:
serial += 1
yield serial
def create_bot(*args, **kwargs):
factory = PokerBotFactory(*args, **kwargs)
bot = Bot(host, port, factory)
factory.bot = bot
bot.setServiceParent(services)
bot_serial = bot_serial_generator()
for table in settings.headerGetProperties("/settings/table"):
table['tournament'] = False
if table.has_key('count'):
for i in range(0, int(table["count"])):
create_bot(settings = settings,
join_info = table,
serial = bot_serial.next())
else:
for bot in settings.headerGetProperties("/settings/table[@name=\"%s\"]/bot" % table['name']):
create_bot(settings = settings,
join_info = table,
serial = bot_serial.next(),
name = bot['name'],
password = bot['password'])
for tournament in settings.headerGetProperties("/settings/tournament"):
tournament['tournament'] = True
if tournament.has_key('count'):
for i in range(0, int(tournament["count"])):
create_bot(settings = settings,
join_info = tournament,
serial = bot_serial.next())
else:
for bot in settings.headerGetProperties("/settings/tournament[@name=\"%s\"]/bot" % tournament['name']):
create_bot(settings = settings,
join_info = table,
serial = bot_serial.next(),
name = bot['name'],
password = bot['password'])
return services
def test01_init_full(self):
settings_xml = """<?xml version="1.0" encoding="UTF-8"?>
<server verbose="6" memcached="127.0.0.1:11211" session_timeout="60" cookie_timeout="120" />
"""
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_xml)
service = PokerServiceMockup()
site = pokersite.PokerSite(settings, pokersite.PokerResource(service))
site.memcache = pokermemcache.MemcacheMockup.Client(['127.0.0.1:11211'])
self.assertEqual(['127.0.0.1:11211'], [str(s) for s in site.memcache.servers])
def test02_AlternatePokerAuth(self):
"""test02_AlternatePokerAuth
Test Poker auth : get_auth_instance alternate PokerAuth"""
db = None
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_alternate_xml,
len(settings_alternate_xml))
settings.header = settings.doc.xpathNewContext()
auth = pokerauth.get_auth_instance(db, settings)
self.failUnless(hasattr(auth, 'gotcha'))
def test04_rootBothUsers(self):
self.settings = pokernetworkconfig.Config([])
self.settings.loadFromString(settings_root_both_users_xml)
try:
self.db = pokerdatabase.PokerDatabase(self.settings)
except MySQLdb.OperationalError as oe:
print self.settings.headerGetProperties('/server/database')[0]
self.assertEquals(oe.args[0], 1396)
self.assertEquals(oe.args[1], "Operation CREATE USER failed for 'root'@'%'")
self.assertEquals(self.db.getVersion(), self.pokerdbVersion)
def test03_schemaFileMissing(self):
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_missing_schema_xml,
len(settings_missing_schema_xml))
settings.header = settings.doc.xpathNewContext()
self.settings = settings
try:
self.db = pokerdatabase.PokerDatabase(self.settings)
assert("Schema file was missing so this line should not be reached.")
except UserWarning, uw:
self.assertEqual(uw.args[0], "PokerDatabase: schema /this/is/not/a/file/and/should/not/be/there/not-my-schema-go-away.sql file not found")
def setUp(self):
self.destroyDb()
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml, len(settings_xml))
settings.header = settings.doc.xpathNewContext()
self.service = pokerservice.PokerService(settings)
if verbose >= 0: self.service.verbose = verbose
site = server.Site(resource.IResource(self.service))
self.p = reactor.listenTCP(0, site, interface="127.0.0.1")
self.port = self.p.getHost().port
self.cookie = None
def setUp(self):
testclock._seconds_reset()
settings_xml = """<?xml version="1.0" encoding="ISO-8859-1"?>
<server verbose="6" />
"""
self.settings = pokernetworkconfig.Config([])
self.settings.loadFromString(settings_xml)
pokermemcache.memcache = pokermemcache.MemcacheMockup
self.service = PokerServiceMockup()
self.site = pokersite.PokerSite(
self.settings, pokersite.PokerAvatarResource(self.service))
def test04_rootBothUsers(self):
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_root_both_users_xml,
len(settings_root_both_users_xml))
settings.header = settings.doc.xpathNewContext()
self.settings = settings
try:
self.db = pokerdatabase.PokerDatabase(self.settings)
except OperationalError, oe:
self.assertEquals(oe.args[0], 1396)
self.assertEquals(oe.args[1], "Operation CREATE USER failed for 'root'@'%'")
def setUp(self):
testclock._seconds_reset()
settings_xml = """<?xml version="1.0" encoding="UTF-8"?>
<server verbose="6" />
"""
self.settings = pokernetworkconfig.Config([])
self.settings.loadFromString(settings_xml)
pokermemcache.memcache = pokermemcache.MemcacheMockup
pokermemcache.memcache_singleton.clear()
pokermemcache.memcache_expiration_singleton.clear()
self.service = PokerServiceMockup()
self.site = pokersite.PokerSite(self.settings, pokersite.PokerTourneyStartResource(self.service))
def setUpServer(self):
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_xml_server)
#
# Setup database
#
self.db = PokerDatabase(settings)
#
# Setup server
#
self.service = pokerservice.PokerService(settings)
self.service.verbose = 6
def test01_init_full(self):
settings_xml = """<?xml version="1.0" encoding="ISO-8859-1"?>
<server verbose="6" memcached="127.0.0.1:11211" session_timeout="60" session_check="10" cookie_timeout="120" />
"""
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_xml)
service = PokerServiceMockup()
site = pokersite.PokerSite(settings, pokersite.PokerResource(service))
self.assertEqual(['127.0.0.1:11211'], site.memcache.addresses)
self.assertEqual(60, site.sessionFactory.sessionTimeout)
self.assertEqual(10, site.sessionCheckTime)
self.assertEqual(120, site.cookieTimeout)
def initProxy(self):
settings = pokernetworkconfig.Config([])
settings.loadFromString(settings_xml_proxy)
self.proxy_service = pokerservice.PokerService(settings)
self.proxy_service.disconnectAll = lambda: True
self.proxy_service.startService()
self.proxy_site = pokersite.PokerSite(
settings, pokerservice.PokerRestTree(self.proxy_service))
self.proxy_site.memcache = pokermemcache.MemcacheMockup.Client([])
self.proxy_port = reactor.listenTCP(19480,
self.proxy_site,
interface="127.0.0.1")
def test06_databaseAlreadyExists(self):
"""Test for when the database already exists"""
self.settings = pokernetworkconfig.Config([])
self.settings.loadFromString(settings_root_both_users_xml)
parameters = self.settings.headerGetProperties("/server/database")[0]
db = MySQLdb.connect(host = parameters["host"],
port = int(parameters.get("port", '3306')),
user = parameters["root_user"],
passwd = parameters["root_password"])
db.query("CREATE DATABASE " + parameters["name"])
db.close()
self.db = pokerdatabase.PokerDatabase(self.settings)
self.assertEquals(self.db.getVersion(), '1.0.5')
def configureApplication(argv):
default_path = "/etc/poker-network/poker.stats.xml"
configuration = argv[-1][-4:] == ".xml" and argv[-1] or default_path
try:
open(configuration, 'r').close()
except:
return None
settings = pokernetworkconfig.Config([''])
settings.load(configuration)
one_time = (len(argv) > 1 and argv[1] == '--one-time') and True or False
return newApplication(settings, one_time)
def test03_authWithAutoCreate(self):
"""test03_authWithAutoCreate
Test Poker auth : Try basic auth with autocreate on"""
db = self.db
settings = pokernetworkconfig.Config([])
autocreate_xml = settings_xml.replace('<server auto_create_account="no" ', '<server auto_create_account="yes" ')
settings.doc = libxml2.parseMemory(autocreate_xml, len(autocreate_xml))
settings.header = settings.doc.xpathNewContext()
auth = pokerauth.get_auth_instance(db, None, settings)
self.assertEquals(auth.auth(PACKET_LOGIN,('joe_schmoe', 'foo')), ((4, 'joe_schmoe', 1), None))
self.assertEquals(log_history.get_all()[-1], 'created user. serial: 4, name: joe_schmoe')
self.failUnless(len(self.checkIfUserExistsInDB('joe_schmoe')) == 1)
def setUpServer(self):
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml_server,
len(settings_xml_server))
settings.header = settings.doc.xpathNewContext()
#
# Setup database
#
self.db = PokerDatabase(settings)
#
# Setup server
#
self.service = pokerservice.PokerService(settings)
self.service.verbose = 6
def test05_missingRootUser(self):
import MySQLdb
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_missing_root_users_xml,
len(settings_missing_root_users_xml))
settings.header = settings.doc.xpathNewContext()
self.settings = settings
try:
self.db = pokerdatabase.PokerDatabase(self.settings)
assert("Root user information was missing so this line should not be reached.")
except MySQLdb.OperationalError, oe: # handle trouble
self.assertEquals(oe.args[1], "Unknown database 'pokernetworktest'")
self.assertEquals(oe.args[0], 1049)
def setUp(self):
testclock._seconds_reset()
settings_xml = """<?xml version="1.0" encoding="UTF-8"?>
<server verbose="6" >
<rest_filter>tests.finishedfilter</rest_filter>
</server>
""" % {
'tests_path': TESTS_PATH
}
self.settings = pokernetworkconfig.Config([])
self.settings.loadFromString(settings_xml)
pokermemcache.memcache = pokermemcache.MemcacheMockup
self.service = PokerServiceMockup()
self.site = pokersite.PokerSite(self.settings, pokersite.PokerResource(self.service))
def setUp(self):
self.tearDown()
settings = pokernetworkconfig.Config([])
settings.doc = libxml2.parseMemory(settings_xml, len(settings_xml))
settings.header = settings.doc.xpathNewContext()
self.settings = settings
r = re.compile("""INSERT\s+INTO\s+server\s+\(\s*version\s*\)\s+VALUES\s*\("([\d\.]+)"\s*\)""", flags=re.I)
infile = open(actualSchemaFile, "r")
self.pokerdbVersion = "0.0.0"
for line in infile:
m = re.match(r, line)
if m:
self.pokerdbVersion = m.group(1)
break
infile.close()
# We should be able to find the version number
self.assertNotEquals(self.pokerdbVersion, "0.0.0")
