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")