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 test01_upgrade(self):
self.db = pokerdatabase.PokerDatabase(self.settings)
self.db.setVersionInDatabase("0.0.0")
self.db.version = version.Version("0.0.0")
good = '%s/test-pokerdatabase/good' % SCRIPT_DIR
self.db.upgrade(good, False)
self.assertEquals(self.db.getVersion(), self.pokerdbVersion)
def test02_dbVersionTooOld(self):
class DummyMySQL:
def get_server_info(self):
return "3.2.5"
def query(self, string):
return string
def close(self):
pass
def dummyConnect(host,
port,
user,
passwd,
db='mysql',
reconnect=1,
cursorclass=None):
parameters = self.settings.headerGetProperties(
"/server/database")[0]
if user == parameters['user'] and user != 'root':
raise Exception("SqlError")
else:
return DummyMySQL()
realconnect = MySQLdb.connect
MySQLdb.connect = dummyConnect
try:
self.db = pokerdatabase.PokerDatabase(self.settings)
except UserWarning, uw:
self.assertEqual(
uw.args[0],
"PokerDatabase: MySQL server version is 3.2.5 but version >= 5.0 is required"
)
def test01_upgrade(self):
self.db = pokerdatabase.PokerDatabase(self.settings)
self.db.setVersionInDatabase("0.0.0")
self.db.version = version.Version("0.0.0")
self.db.upgrade(path.join(TESTS_PATH, 'test_pokerdatabase/good'),
False)
self.assertEquals(self.db.getVersion(), self.pokerdbVersion)
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()
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 test10_badUpgradeSqlFiles(self):
self.db = pokerdatabase.PokerDatabase(self.settings)
self.db.setVersionInDatabase("0.0.5")
self.db.version = version.Version("0.0.5")
try:
with warnings.catch_warnings():
warnings.simplefilter('ignore', _mysql_exceptions.Error)
self.db.upgrade(path.join(TESTS_PATH, 'test_pokerdatabase/bad'), False)
except pokerdatabase.ExceptionUpgradeFailed, euf:
self.assertEquals(euf.args[0], "upgrade failed")
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 test10_badUpgradeSqlFiles(self):
self.db = pokerdatabase.PokerDatabase(self.settings)
self.db.setVersionInDatabase("0.0.5")
self.db.version = version.Version("0.0.5")
try:
bad = '%s/test-pokerdatabase/bad' % SCRIPT_DIR
self.db.upgrade(bad, False)
assert("Should have gotten ExceptionUpgradeFailed and this line should not have been reached.")
except pokerdatabase.ExceptionUpgradeFailed, euf:
self.assertEquals(euf.args[0], "upgrade failed")
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 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 test11_confirmLiteralMethodPassThrough(self):
"""test11_confirmLiteralMethodPassThrough
The method "literal" in the database class should simply pass
through to the internal representation method of the same name."""
class MockDatabaseWithOnlyLiteral():
def literal(mdSelf, args): return "LITERAL TEST " + args
self.db = pokerdatabase.PokerDatabase(self.settings)
saveRealDb = self.db.db
self.db.db = MockDatabaseWithOnlyLiteral()
self.assertEquals(self.db.literal("ahoy hoy!"), "LITERAL TEST ahoy hoy!")
self.db.db = saveRealDb
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 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 test09_forceTestPokerNetworkTooOld(self):
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]
try:
self.db = pokerdatabase.PokerDatabase(self.settings)
import pokernetwork.version
ver = pokernetwork.version.Version("32767.32767.32767")
realDBVersion = self.db.version
self.db.version = ver
self.db.checkVersion()
assert("Should have gotten ExceptionSoftwareTooOld and this line should not have been reached.")
except pokerdatabase.ExceptionSoftwareTooOld, edto:
self.assertEquals(edto.args, ())
self.db.version = realDBVersion # Restore original version
if __name__ == '__main__':
usage = """%prog [OPTIONS] EMAIL SERVER_CONFIG
Generates an API key and secret for a given user EMAIL, and saves the result
to the pokerserver database as specified in SERVER_CONFIG"""
parser = optparse.OptionParser(usage=usage)
options, args = parser.parse_args()
try:
email = args[0]
configpath = args[1]
except Exception, e:
parser.print_help()
sys.exit(1)
config = _load_config(configpath)
db = pokerdatabase.PokerDatabase(config)
api_user_store = apiserver.APIUserStore(db)
key, secret = generate_key_secret_pair()
api_user_store.add_user(email, key, secret)
print """\
The following API user has been added:
email: %s
key: %s
secret: %s
Please store this information in a safe location.""" % (email, key, secret)
def makeService(configuration):
settings = Config([''])
settings.load(configuration)
if not settings.header:
sys.exit(1)
serviceCollection = service.MultiService()
poker_service = PokerService(settings)
poker_service.setServiceParent(serviceCollection)
poker_factory = IPokerFactory(poker_service)
#
# Poker protocol (with or without SSL)
#
tcp_port = settings.headerGetInt("/server/listen/@tcp")
internet.TCPServer(tcp_port,
poker_factory).setServiceParent(serviceCollection)
tcp_ssl_port = settings.headerGetInt("/server/listen/@tcp_ssl")
if HAS_OPENSSL and tcp_ssl_port:
internet.SSLServer(
tcp_ssl_port, poker_factory,
SSLContextFactory(settings)).setServiceParent(serviceCollection)
rest_site = PokerSite(settings, PokerRestTree(poker_service))
#
# HTTP (with or without SLL) that implements REST
#
rest_port = settings.headerGetInt("/server/listen/@rest")
if rest_port:
internet.TCPServer(rest_port,
rest_site).setServiceParent(serviceCollection)
rest_ssl_port = settings.headerGetInt("/server/listen/@rest_ssl")
if HAS_OPENSSL and rest_ssl_port:
internet.SSLServer(
rest_ssl_port, rest_site,
SSLContextFactory(settings)).setServiceParent(serviceCollection)
http_site = server.Site(PokerTree(poker_service))
#
# HTTP (with or without SLL) that implements XML-RPC and SOAP
#
http_port = settings.headerGetInt("/server/listen/@http")
if http_port:
internet.TCPServer(http_port,
http_site).setServiceParent(serviceCollection)
http_ssl_port = settings.headerGetInt("/server/listen/@http_ssl")
if HAS_OPENSSL and http_ssl_port:
internet.SSLServer(
http_ssl_port, http_site,
SSLContextFactory(settings)).setServiceParent(serviceCollection)
# API
api_ssl_port = settings.headerGetInt("/server/listen/@api_ssl")
if HAS_OPENSSL and api_ssl_port:
from pokernetwork import apiserver, apiservice
poker_database = pokerdatabase.PokerDatabase(settings)
secret_store = apiserver.APIUserStore(poker_database)
api_service = apiservice.APIService(poker_service)
api_site = server.Site(apiserver.Root(api_service, secret_store))
internet.SSLServer(
api_ssl_port, api_site,
SSLContextFactory(settings)).setServiceParent(serviceCollection)
else:
print 'Could not create API service!'
#
# TELNET twisted.manhole (without SSL)
#
manhole_port = settings.headerGetInt("/server/listen/@manhole")
if manhole_port:
manhole_factory = telnet.ShellFactory()
manhole_factory.namespace['poker_service'] = poker_service
manhole_factory.namespace['poker_site'] = rest_site
manhole_service = internet.TCPServer(manhole_port,
manhole_factory,
interface='127.0.0.1')
manhole_service.setName("manhole")
manhole_service.setServiceParent(serviceCollection)
if settings.headerGetInt("/server/@verbose") > 0:
print "PokerManhole: manhole is useful for debugging, use with telnet admin/admin, however, it can be a security risk and should be used only during debugging"
return serviceCollection
