class PokerCrashTestCase(unittest.TestCase): def destroyDb(self, arg = None): os.system("/usr/bin/mysql -u root -e 'DROP DATABASE IF EXISTS pokernetworktest'") 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 setUp(self): self.destroyDb() self.setUpServer() def tearDown(self): self.db.close() return self.service.stopService() def test01_cleanupCrashedTables(self): cursor = self.db.cursor() # # Although the name is not in the configuration file (settings), # it has a matching resthost_serial and is cleanedup # cursor.execute('INSERT INTO pokertables (serial, name, variant, betting_structure, currency_serial) VALUES (142, "one", "holdem", "2-4", 1)') cursor.execute('INSERT INTO user2table (user_serial, table_serial, money, bet) VALUES (1000, 142, 10, 1)') cursor.execute("INSERT INTO users (serial, created, name) VALUES (1000, 0, 'testuser')") cursor.execute("INSERT INTO user2money (user_serial, currency_serial, amount) VALUES (1000, 1, 0)") # # resthost_serial does not match, the records are left untouched # cursor.execute('INSERT INTO pokertables (serial, name, variant, betting_structure, currency_serial, resthost_serial) VALUES (202, "two", "holdem", "2-4", 1, 10)') cursor.execute('INSERT INTO user2table (user_serial, table_serial, money, bet) VALUES (1000, 202, 10, 1)') # # Table1 is in the configuration file and cleaned up even though # resthost_serial does not match # cursor.execute('INSERT INTO pokertables (serial, name, variant, betting_structure, currency_serial, resthost_serial) VALUES (303, "Table1", "holdem", "2-4", 1, 44)') self.service.startService() cursor.execute("SELECT user_serial,table_serial FROM user2table") self.assertEqual(1, cursor.rowcount) self.assertEqual((1000, 202), cursor.fetchone()) cursor.execute("SELECT serial FROM pokertables") self.assertEqual((202,), cursor.fetchone()) cursor.execute("SELECT amount FROM user2money") self.assertEqual(11, cursor.fetchone()[0]) cursor.close() def test02_cleanupTourneys_refund(self): tourney_serial = '10' user_serial = '200' buy_in = '300' currency_serial = '44' cursor = self.db.cursor() cursor.execute('INSERT INTO tourneys (serial,name,buy_in,currency_serial) VALUES (%s, "one", %s, %s)', ( tourney_serial, buy_in, currency_serial )) cursor.execute('INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', ( user_serial, tourney_serial )) cursor.execute('INSERT INTO user2money (user_serial,currency_serial) VALUES (%s,%s)', ( user_serial, currency_serial )) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', ( user_serial, currency_serial )) self.assertEqual((0,), cursor.fetchone()) self.service.startService() cursor.execute('SELECT * FROM tourneys WHERE serial = ' + tourney_serial) self.assertEqual(0, cursor.rowcount) cursor.execute('SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', ( user_serial, currency_serial )) self.assertEqual((300,), cursor.fetchone()) cursor.close() def test02_cleanupTourneys_restore(self): regular_tourney_serial = '10' sng_tourney_serial = '40' user_serial = '200' cursor = self.db.cursor() cursor.execute("DELETE FROM tourneys_schedule") # # Sit and go in 'registering' state is trashed # cursor.execute('INSERT INTO tourneys (serial,name) VALUES (%s, "one")', sng_tourney_serial) cursor.execute('INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', ( user_serial, sng_tourney_serial )) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + sng_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Regular in 'registering' state is kept # cursor.execute('INSERT INTO tourneys (serial,name,sit_n_go,start_time) VALUES (%s, "one", "n", %s)', ( regular_tourney_serial, seconds() + 2000)) cursor.execute('INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', ( user_serial, regular_tourney_serial )) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + regular_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Run cleanupTourneys as a side effect # self.service.startService() # # Sanity checks # self.assertEqual([int(regular_tourney_serial)], self.service.tourneys.keys()) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', regular_tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', sng_tourney_serial) self.assertEqual(0, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney') self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM tourneys') self.assertEqual(1, cursor.rowcount) cursor.close()
class PokerCrashTestCase(unittest.TestCase): def destroyDb(self, arg=None): os.system( "/usr/bin/mysql -u root -e 'DROP DATABASE IF EXISTS pokernetworktest'" ) 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 setUp(self): self.destroyDb() self.setUpServer() def tearDown(self): self.db.close() return self.service.stopService() def test01_cleanupCrashedTables(self): cursor = self.db.cursor() # # Although the name is not in the configuration file (settings), # it has a matching resthost_serial and is cleanedup # cursor.execute( 'INSERT INTO pokertables (serial, name, variant, betting_structure, currency_serial) VALUES (142, "one", "holdem", "2-4", 1)' ) cursor.execute( 'INSERT INTO user2table (user_serial, table_serial, money, bet) VALUES (1000, 142, 10, 1)' ) cursor.execute( "INSERT INTO users (serial, created, name) VALUES (1000, 0, 'testuser')" ) cursor.execute( "INSERT INTO user2money (user_serial, currency_serial, amount) VALUES (1000, 1, 0)" ) # # resthost_serial does not match, the records are left untouched # cursor.execute( 'INSERT INTO pokertables (serial, name, variant, betting_structure, currency_serial, resthost_serial) VALUES (202, "two", "holdem", "2-4", 1, 10)' ) cursor.execute( 'INSERT INTO user2table (user_serial, table_serial, money, bet) VALUES (1000, 202, 10, 1)' ) # # Table1 is in the configuration file and cleaned up even though # resthost_serial does not match # cursor.execute( 'INSERT INTO pokertables (serial, name, variant, betting_structure, currency_serial, resthost_serial) VALUES (303, "Table1", "holdem", "2-4", 1, 44)' ) self.service.startService() cursor.execute("SELECT user_serial,table_serial FROM user2table") self.assertEqual(1, cursor.rowcount) self.assertEqual((1000, 202), cursor.fetchone()) cursor.execute("SELECT serial FROM pokertables") self.assertEqual((202, ), cursor.fetchone()) cursor.execute("SELECT amount FROM user2money") self.assertEqual(11, cursor.fetchone()[0]) cursor.close() def test02_cleanupTourneys_refund(self): tourney_serial = '10' user_serial = '200' buy_in = '300' currency_serial = '44' cursor = self.db.cursor() cursor.execute( 'INSERT INTO tourneys (serial,name,buy_in,currency_serial) VALUES (%s, "one", %s, %s)', (tourney_serial, buy_in, currency_serial)) cursor.execute( 'INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', (user_serial, tourney_serial)) cursor.execute( 'INSERT INTO user2money (user_serial,currency_serial) VALUES (%s,%s)', (user_serial, currency_serial)) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute( 'SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', (user_serial, currency_serial)) self.assertEqual((0, ), cursor.fetchone()) self.service.startService() cursor.execute('SELECT * FROM tourneys WHERE serial = ' + tourney_serial) self.assertEqual(0, cursor.rowcount) cursor.execute( 'SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', (user_serial, currency_serial)) self.assertEqual((300, ), cursor.fetchone()) cursor.close() def test02_cleanupTourneys_restore(self): regular_tourney_serial = '10' sng_tourney_serial = '40' user_serial = '200' cursor = self.db.cursor() cursor.execute("DELETE FROM tourneys_schedule") # # Sit and go in 'registering' state is trashed # cursor.execute('INSERT INTO tourneys (serial,name) VALUES (%s, "one")', sng_tourney_serial) cursor.execute( 'INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', (user_serial, sng_tourney_serial)) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + sng_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Regular in 'registering' state is kept # cursor.execute( 'INSERT INTO tourneys (serial,name,sit_n_go,start_time) VALUES (%s, "one", "n", %s)', (regular_tourney_serial, seconds() + 2000)) cursor.execute( 'INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', (user_serial, regular_tourney_serial)) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + regular_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Run cleanupTourneys as a side effect # self.service.startService() # # Sanity checks # self.assertEqual([int(regular_tourney_serial)], self.service.tourneys.keys()) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', regular_tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', sng_tourney_serial) self.assertEqual(0, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney') self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM tourneys') self.assertEqual(1, cursor.rowcount) cursor.close()
class PokerCrashTestCase(unittest.TestCase): def destroyDb(self, *a): sqlmanager.query("DROP DATABASE IF EXISTS %s" % (config.test.mysql.database,), user=config.test.mysql.root_user.name, password=config.test.mysql.root_user.password, host=config.test.mysql.host ) 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 setUp(self): self.destroyDb() self.setUpServer() def tearDown(self): self.db.close() return self.service.stopService() def test01_cleanupCrashedTables(self): cursor = self.db.cursor() # # Although the name is not in the configuration file (settings), # it has a matching resthost_serial and is cleanedup # cursor.execute('INSERT INTO user2table (user_serial, table_serial, money) VALUES (1000, 142, 10)') cursor.execute("INSERT INTO users (serial, created, name, password) VALUES (1000, 0, 'testuser', '')") cursor.execute("INSERT INTO user2money (user_serial, currency_serial, amount) VALUES (1000, 1, 0)") # # resthost_serial does not match, the records are left untouched # cursor.execute('INSERT INTO user2table (user_serial, table_serial, money) VALUES (1000, 202, 10)') # # Table1 is in the configuration file and cleaned up even though # resthost_serial does not match # cursor.execute('INSERT INTO tableconfigs (serial, name, variant, betting_structure, currency_serial) VALUES (1, "Table1", "holdem", "2-4-no-limit", 1)') cursor.execute('INSERT INTO tables (serial, resthost_serial, tableconfig_serial) VALUES (303, 1, 1)') self.service.startService() cursor.execute("SELECT user_serial,table_serial FROM user2table") self.assertEqual(2, cursor.rowcount) self.assertEqual(((1000, 142),(1000, 202)), cursor.fetchall()) cursor.execute("SELECT serial FROM tables") self.assertEqual((303,), cursor.fetchone()) cursor.execute("SELECT amount FROM user2money") #TODO this test sucks, data gets intermixed, rework! # self.assertEqual(11, cursor.fetchall()) cursor.close() def test02_cleanupTourneys_refund(self): tourney_serial = '10' user_serial = '200' buy_in = '300' currency_serial = '44' cursor = self.db.cursor() cursor.execute('INSERT INTO tourneys (serial,name,buy_in,currency_serial,description_short,description_long,variant,betting_structure,schedule_serial,resthost_serial,sit_n_go) VALUES (%s, "one", %s, %s, "", "", "holdem", "2-4-no-limit", 0, 1, "n")', ( tourney_serial, buy_in, currency_serial )) cursor.execute('INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', ( user_serial, tourney_serial )) cursor.execute('INSERT INTO user2money (user_serial,currency_serial,amount) VALUES (%s,%s,0)', ( user_serial, currency_serial )) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', ( user_serial, currency_serial )) self.assertEqual((0,), cursor.fetchone()) self.service.startService() cursor.execute('SELECT * FROM tourneys WHERE serial = %s', tourney_serial) self.assertEqual(0, cursor.rowcount) cursor.execute('SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', ( user_serial, currency_serial )) self.assertEqual((300,), cursor.fetchone()) cursor.close() def test02_cleanupTourneys_restore(self): regular_tourney_serial = '10' sng_tourney_serial = '40' user_serial = '200' cursor = self.db.cursor() cursor.execute("DELETE FROM tourneys_schedule") # # Sit and go in 'registering' state is trashed # cursor.execute('INSERT INTO tourneys (serial,name,description_short,description_long,variant,betting_structure,currency_serial,schedule_serial, resthost_serial) VALUES (%s, "one", "", "", "holdem", "2-4-no-limit", 0, 0, 1)', sng_tourney_serial) cursor.execute('INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', ( user_serial, sng_tourney_serial )) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + sng_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Regular in 'registering' state is kept # cursor.execute('INSERT INTO tourneys (serial,name,sit_n_go,start_time,description_short,description_long,variant,betting_structure,currency_serial,schedule_serial, resthost_serial) VALUES (%s, "one", "n", %s, "", "", "holdem", "2-4-no-limit", 0, 0, 1)', ( regular_tourney_serial, seconds() + 2000)) cursor.execute('INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', ( user_serial, regular_tourney_serial )) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + regular_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Run cleanupTourneys as a side effect # self.service.startService() # # Sanity checks # self.assertEqual([int(sng_tourney_serial), int(regular_tourney_serial)], self.service.tourneys.keys()) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', regular_tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', sng_tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney') self.assertEqual(2, cursor.rowcount) cursor.execute('SELECT * FROM tourneys') self.assertEqual(2, cursor.rowcount) cursor.close()
class PokerCrashTestCase(unittest.TestCase): def destroyDb(self, *a): sqlmanager.query("DROP DATABASE IF EXISTS %s" % (config.test.mysql.database, ), user=config.test.mysql.root_user.name, password=config.test.mysql.root_user.password, host=config.test.mysql.host) 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 setUp(self): self.destroyDb() self.setUpServer() def tearDown(self): self.db.close() return self.service.stopService() def test01_cleanupCrashedTables(self): cursor = self.db.cursor() # # Although the name is not in the configuration file (settings), # it has a matching resthost_serial and is cleanedup # cursor.execute( 'INSERT INTO user2table (user_serial, table_serial, money) VALUES (1000, 142, 10)' ) cursor.execute( "INSERT INTO users (serial, created, name, password) VALUES (1000, 0, 'testuser', '')" ) cursor.execute( "INSERT INTO user2money (user_serial, currency_serial, amount) VALUES (1000, 1, 0)" ) # # resthost_serial does not match, the records are left untouched # cursor.execute( 'INSERT INTO user2table (user_serial, table_serial, money) VALUES (1000, 202, 10)' ) # # Table1 is in the configuration file and cleaned up even though # resthost_serial does not match # cursor.execute( 'INSERT INTO tableconfigs (serial, name, variant, betting_structure, currency_serial) VALUES (1, "Table1", "holdem", "2-4-no-limit", 1)' ) cursor.execute( 'INSERT INTO tables (serial, resthost_serial, tableconfig_serial) VALUES (303, 1, 1)' ) self.service.startService() cursor.execute("SELECT user_serial,table_serial FROM user2table") self.assertEqual(2, cursor.rowcount) self.assertEqual(((1000, 142), (1000, 202)), cursor.fetchall()) cursor.execute("SELECT serial FROM tables") self.assertEqual((303, ), cursor.fetchone()) cursor.execute("SELECT amount FROM user2money") #TODO this test sucks, data gets intermixed, rework! # self.assertEqual(11, cursor.fetchall()) cursor.close() def test02_cleanupTourneys_refund(self): tourney_serial = '10' user_serial = '200' buy_in = '300' currency_serial = '44' cursor = self.db.cursor() cursor.execute( 'INSERT INTO tourneys (serial,name,buy_in,currency_serial,description_short,description_long,variant,betting_structure,schedule_serial,resthost_serial,sit_n_go) VALUES (%s, "one", %s, %s, "", "", "holdem", "2-4-no-limit", 0, 1, "n")', (tourney_serial, buy_in, currency_serial)) cursor.execute( 'INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', (user_serial, tourney_serial)) cursor.execute( 'INSERT INTO user2money (user_serial,currency_serial,amount) VALUES (%s,%s,0)', (user_serial, currency_serial)) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute( 'SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', (user_serial, currency_serial)) self.assertEqual((0, ), cursor.fetchone()) self.service.startService() cursor.execute('SELECT * FROM tourneys WHERE serial = %s', tourney_serial) self.assertEqual(0, cursor.rowcount) cursor.execute( 'SELECT amount FROM user2money WHERE user_serial = %s AND currency_serial = %s', (user_serial, currency_serial)) self.assertEqual((300, ), cursor.fetchone()) cursor.close() def test02_cleanupTourneys_restore(self): regular_tourney_serial = '10' sng_tourney_serial = '40' user_serial = '200' cursor = self.db.cursor() cursor.execute("DELETE FROM tourneys_schedule") # # Sit and go in 'registering' state is trashed # cursor.execute( 'INSERT INTO tourneys (serial,name,description_short,description_long,variant,betting_structure,currency_serial,schedule_serial, resthost_serial) VALUES (%s, "one", "", "", "holdem", "2-4-no-limit", 0, 0, 1)', sng_tourney_serial) cursor.execute( 'INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', (user_serial, sng_tourney_serial)) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + sng_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Regular in 'registering' state is kept # cursor.execute( 'INSERT INTO tourneys (serial,name,sit_n_go,start_time,description_short,description_long,variant,betting_structure,currency_serial,schedule_serial, resthost_serial) VALUES (%s, "one", "n", %s, "", "", "holdem", "2-4-no-limit", 0, 0, 1)', (regular_tourney_serial, seconds() + 2000)) cursor.execute( 'INSERT INTO user2tourney (user_serial,currency_serial,tourney_serial) VALUES (%s,1,%s)', (user_serial, regular_tourney_serial)) cursor.execute('SELECT * FROM tourneys WHERE serial = ' + regular_tourney_serial) self.assertEqual(1, cursor.rowcount) # # Run cleanupTourneys as a side effect # self.service.startService() # # Sanity checks # self.assertEqual( [int(sng_tourney_serial), int(regular_tourney_serial)], self.service.tourneys.keys()) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', regular_tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney WHERE tourney_serial = %s', sng_tourney_serial) self.assertEqual(1, cursor.rowcount) cursor.execute('SELECT * FROM user2tourney') self.assertEqual(2, cursor.rowcount) cursor.execute('SELECT * FROM tourneys') self.assertEqual(2, cursor.rowcount) cursor.close()