def DONTtest_get_multiple(self):
m = self.protocol.transport = MockTransport()
d1 = self.protocol.get("a")
assert self.protocol.lock.locked
def send(k, v):
self.protocol.lineReceived('VALUE %s 0 %d' % (k, len(v)))
self.protocol.rawDataReceived("%s\r\n" % v)
self.protocol.lineReceived('END')
reactor.callLater(0, send, "a", "123")
def got_a((k, v)):
assert k == 'a'
assert v == '123'
assert self.protocol.lock.locked
assert m.value() == 'get a\r\n'
assert [k for (_, k) in self.protocol.requests] == ['b']
m.buffer = []
reactor.callLater(0, send, "b", "456")
d1.addCallback(got_a)
d2 = self.protocol.get("b")
final_d = defer.Deferred()
def got_b((k, v)):
assert k == 'b'
assert v == '456'
assert self.protocol.lock.locked
assert m.value() == 'get b\r\n'
m.buffer = []
assert [k for (_, k) in self.protocol.requests] == []
reactor.callLater(0, final_d.callback, None)
d2.addCallback(got_b)
def final(_):
assert not self.protocol.lock.locked
final_d.addCallback(final)
assert [k for (_, k) in self.protocol.requests] == ['b', 'a']
return final_d
def test_stats_with_collectd_for_installing_new_container(self):
df = defer.Deferred()
def collectd_sample(df):
if 'NEW' in self.serverOptionsList:
test_image = 'cord-test/exserver'
test_name = 'cord-collectd'
## stopping collectd agent on test container if any
cmd = 'sudo /etc/init.d/collectd stop'
output = os.system(cmd)
## starting collectd agent on new container
cmd = 'sudo /etc/init.d/collectd start'
output = self.start_collectd_agent_in_server(name=test_name,
image=test_image)
if output == 0:
log.info('Collectd is installed properly on new container')
pass
else:
log.info(
'Collectd is not installed properly on new container')
assert_equal(False, True)
df.callback(0)
reactor.callLater(0, collectd_sample, df)
return df
def testSocketToNode(self):
"""Transfert entre un socket UNIX et le bus"""
msg_sent = "event|dummy|dummy|dummy|dummy|dummy"
msg_sent_dict = {
"type": "event",
"timestamp": "dummy",
"host": "dummy",
"service": "dummy",
"state": "dummy",
"message": "dummy",
}
consumer = ConsumerStub()
self.sl.consumer = consumer
# client
reactor.connectUNIX(self.socket, SendingFactory(msg_sent))
d = defer.Deferred()
def get_output():
self.assertEqual(len(consumer.written), 1)
msg = consumer.written[0]
d.callback(msg)
def check_msg(msg):
print msg
self.assertEquals(msg, msg_sent_dict)
# On laisse un peu de temps pour traiter
reactor.callLater(0.5, get_output)
d.addCallback(check_msg)
return d
def test_multiple_tcp_sessions_using_iperf(self):
df = defer.Deferred()
def iperf_network_test(df):
cmd = 'iperf -c 172.17.0.2 -p 6653 -t 5 -P 2 -i 1'
self.iperf_tool_cmd_execution(cmd = cmd)
df.callback(0)
reactor.callLater(0, iperf_network_test, df)
return df
def got_b((k, v)):
assert k == 'b'
assert v == '456'
assert self.protocol.lock.locked
assert m.value() == 'get b\r\n'
m.buffer = []
assert [k for (_, k) in self.protocol.requests] == []
reactor.callLater(0, final_d.callback, None)
def got_a((k, v)):
assert k == 'a'
assert v == '123'
assert self.protocol.lock.locked
assert m.value() == 'get a\r\n'
assert [k for (_, k) in self.protocol.requests] == ['b']
m.buffer = []
reactor.callLater(0, send, "b", "456")
def test01_sixPlayersTourney5PerTable(self):
"""test01_sixPlayersTourney5PerTable
Test the condition where six players sign up for a tourney that
has five people per table. It has been reported that this causes
5 people at one table and 1 player at the other"""
pokerservice.UPDATE_TOURNEYS_SCHEDULE_DELAY = 1
pokerservice.CHECK_TOURNEYS_SCHEDULE_DELAY = 0.1
cursor = self.db.cursor()
cursor.execute(
"INSERT INTO `tourneys_schedule` (`name`, `description_short`, `description_long`, `players_quota`, `variant`, `betting_structure`, `seats_per_game`, `currency_serial`, `buy_in`, `rake`, `sit_n_go`, `start_time`, `register_time`, `respawn`, `respawn_interval`, `players_min`, `breaks_first`)" \
"VALUES ('Only6', 'Sit and Go 6 players and only 6, Holdem', 'Sit and Go 6 players only', '6', 'holdem', 'level-15-30-no-limit', '5', 1, '0', '0', 'y', '0', '0', 'y', '0', '6', 1 )"
)
cursor.close()
self.service.startService()
self.createUsers(6)
tourneys = self.service.tourneySelect('Only6')
self.assertEquals(len(tourneys), 1)
t = tourneys[0]
self.assertEquals(t['name'], 'Only6')
self.assertEquals(t['betting_structure'], 'level-15-30-no-limit')
self.assertEquals(t['players_quota'], 6L)
self.assertEquals(t['players_min'], 6L)
self.assertEquals(t['seats_per_game'], 5L)
tourney_serial = t['serial']
clients = {}
for user_serial in self.user_serials:
clients[user_serial] = ClientMockup(user_serial)
self.service.avatar_collection.add(clients[user_serial])
self.service.tourneyRegister(
PacketPokerTourneyRegister(serial=user_serial,
tourney_serial=tourney_serial))
tourneys = self.service.tourneys.values()
sixTourney = [
t for t in self.service.tourneys.itervalues() if t.name == 'Only6'
][0]
self.assertEquals(sixTourney.serial, tourney_serial)
d = defer.Deferred()
def checkTourney(status):
self.assertEquals(pokertournament.TOURNAMENT_STATE_RUNNING,
sixTourney.state)
for game in sixTourney.games:
# tables should be equalized
self.assertTrue(len(game.serial2player.keys()) >= 2)
d.addCallback(checkTourney)
reactor.callLater(3, d.callback, True)
return d
def test_multiple_udp_sessions_using_iperf(self):
df = defer.Deferred()
def iperf_network_test(df):
cmd = 'iperf -c 172.17.0.2 -p 6653 -u -t 5 -P 2 -i 1'
log.info('Test Controller by executing a iperf tool command on host = {}'.format(cmd))
status = os.system(cmd)
df.callback(0)
reactor.callLater(0, iperf_network_test, df)
return df
def test_tcp_mss_with_9000Bytes_for_max_throughput_using_iperf(self):
df = defer.Deferred()
def iperf_network_test(df):
cmd = 'iperf -c 172.17.0.2 -p 6653 -t 20 -P 1 -i 1 -m -M 9000'
log.info('Test Controller by executing a iperf tool command on host = {}'.format(cmd))
status = os.system(cmd)
df.callback(0)
reactor.callLater(0, iperf_network_test, df)
return df
def test_tcp_window_of_520k_using_iperf(self):
df = defer.Deferred()
def iperf_network_test(df):
cmd = 'iperf -c 172.17.0.2 -p 6653 -t 20 -P 1 -i 1 -w 520k'
log.info('Test Controller by executing a iperf tool command on host = {}'.format(cmd))
status = os.system(cmd)
df.callback(0)
reactor.callLater(0, iperf_network_test, df)
return df
def test_eap_tls(self):
df = defer.Deferred()
def eap_tls_verify(df):
tls = TLSAuthTest()
tls.runTest()
df.callback(0)
reactor.callLater(0, eap_tls_verify, df)
return df
def test_udp_using_iperf(self):
df = defer.Deferred()
def iperf_network_test(df):
cmd = 'iperf -c 172.17.0.2 -p 6653 -u -t 20 -P 1 -i 1'
log.info('Test Controller by executing a iperf tool command on host = {}'.format(cmd))
status = os.system(cmd)
self.onos_ctrl = OnosCtrl(self.app)
df.callback(0)
reactor.callLater(0, iperf_network_test, df)
return df
def test_eap_tls_Nusers_with_same_valid_cert(self):
df = defer.Deferred()
def eap_tls_Nusers_with_same_valid_cert(df):
num_users = 3
for i in xrange(num_users):
tls = TLSAuthTest(intf='veth{}'.format(i * 2))
tls.runTest()
df.callback(0)
reactor.callLater(0, eap_tls_Nusers_with_same_valid_cert, df)
return df
def test_eap_tls_5k_sessions_with_diff_mac(self):
df = defer.Deferred()
def eap_tls_5k_with_diff_mac(df):
for i in xrange(5000):
tls = TLSAuthTest(src_mac='random')
tls.runTest()
log_test.info('Authentication successfull for user %d' % i)
df.callback(0)
reactor.callLater(0, eap_tls_5k_with_diff_mac, df)
return df
def test01_sixPlayersTourney5PerTable(self):
"""test01_sixPlayersTourney5PerTable
Test the condition where six players sign up for a tourney that
has five people per table. It has been reported that this causes
5 people at one table and 1 player at the other"""
pokerservice.UPDATE_TOURNEYS_SCHEDULE_DELAY = 1
pokerservice.CHECK_TOURNEYS_SCHEDULE_DELAY = 0.1
cursor = self.db.cursor()
cursor.execute(
"INSERT INTO `tourneys_schedule` (`name`, `description_short`, `description_long`, `players_quota`, `variant`, `betting_structure`, `seats_per_game`, `currency_serial`, `buy_in`, `rake`, `sit_n_go`, `start_time`, `register_time`, `respawn`, `respawn_interval`, `players_min`, `breaks_first`)" \
"VALUES ('Only6', 'Sit and Go 6 players and only 6, Holdem', 'Sit and Go 6 players only', '6', 'holdem', 'level-15-30-no-limit', '5', 1, '0', '0', 'y', '0', '0', 'y', '0', '6', 1 )"
)
cursor.close()
self.service.startService()
self.createUsers(6)
tourneys = self.service.tourneySelect('Only6')
self.assertEquals(len(tourneys), 1)
t = tourneys[0]
self.assertEquals(t['name'], 'Only6')
self.assertEquals(t['betting_structure'], 'level-15-30-no-limit')
self.assertEquals(t['players_quota'], 6L)
self.assertEquals(t['players_min'], 6L)
self.assertEquals(t['seats_per_game'], 5L)
tourney_serial = t['serial']
clients = {}
for user_serial in self.user_serials:
clients[user_serial] = ClientMockup(user_serial)
self.service.avatar_collection.add(clients[user_serial])
self.service.tourneyRegister(PacketPokerTourneyRegister(serial=user_serial, tourney_serial=tourney_serial))
tourneys = self.service.tourneys.values()
sixTourney = [t for t in self.service.tourneys.itervalues() if t.name=='Only6'][0]
self.assertEquals(sixTourney.serial, tourney_serial)
d = defer.Deferred()
def checkTourney(status):
self.assertEquals(pokertournament.TOURNAMENT_STATE_RUNNING, sixTourney.state)
for game in sixTourney.games:
# tables should be equalized
self.assertTrue(len(game.serial2player.keys()) >= 2)
d.addCallback(checkTourney)
reactor.callLater(3, d.callback, True)
return d
def xtest_connect_to_transmission(self):
import logging
logging.basicConfig(level=logging.DEBUG)
ubuntu = get_torrent()
client = BitPy.client.Client(ubuntu)
peer = client.add_peer('localhost', 1500)
client.connect_peer(peer)
d = defer.Deferred()
def check_bitfield(d):
assert_true(any([x>0 for x in peer.bitfield]))
reactor.callLater(10, d.callback,'f')
d.addCallback(check_bitfield)
return d
def test_call_threadsafe(self):
# Verify that the method is actually called using the reactor's
# callFromThread method.
callback = mock.Mock()
self.conn._adapter_add_callback_threadsafe(callback)
d = defer.Deferred()
def check():
callback.assert_called_once()
d.callback(None)
# Give time to run the callFromThread call
reactor.callLater(0.1, check)
return d
def test_call_threadsafe(self):
# Verify that the method is actually called using the reactor's
# callFromThread method.
callback = mock.Mock()
self.conn._adapter_add_callback_threadsafe(callback)
d = defer.Deferred()
def check():
callback.assert_called_once()
d.callback(None)
# Give time to run the callFromThread call
reactor.callLater(0.1, check)
return d
def test_eap_tls_with_no_cert(self):
df = defer.Deferred()
def eap_tls_no_cert(df):
def tls_no_cert_cb():
log_test.info('TLS authentication failed with no certificate')
tls = TLSAuthTest(fail_cb=tls_no_cert_cb, client_cert='')
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_no_cert, df)
return df
def test_eap_tls_without_sending_client_hello(self):
df = defer.Deferred()
def eap_tls_without_sending_client_hello(df):
def tls_without_sending_client_hello_cb():
log_test.info(
'TLS authentication failed with not sending client hello')
tls = TLSAuthTest(fail_cb=tls_without_sending_client_hello_cb,
dont_send_client_hello=True)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_without_sending_client_hello, df)
return df
def test_stats_with_collectd_installation(self):
df = defer.Deferred()
def collectd_sample(df):
cmd = 'sudo /etc/init.d/collectd start'
output = subprocess.check_output(cmd, shell=True)
if 'Starting statistics collectio' in output:
log.info('Collectd is installed properly')
pass
else:
log.info('Collectd is not installed properly')
assert_equal(False, True)
df.callback(0)
reactor.callLater(0, collectd_sample, df)
return df
def test_eap_tls_with_invalid_source_mac_zero(self):
df = defer.Deferred()
def eap_tls_invalid_source_mac_zero(df):
def tls_invalid_source_mac_zero_cb():
log_test.info(
'TLS authentication failed with invalid source mac as zero in EAPOL packet'
)
tls = TLSAuthTest(fail_cb=tls_invalid_source_mac_zero_cb,
src_mac='zeros')
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_invalid_source_mac_zero, df)
return df
def get_requests(self):
d = dfr.Deferred()
def fire(f):
log.debug(
"Fire on queue:%s len: %s",
f,
len(self.requests),
)
try:
f.callback(self.requests.pop())
except IndexError:
log.debug("Queue empty")
f.callback(None) # empty queue
reactor.callLater(0.01, fire, d)
return d
def firstRounds(status):
for game in tourney.games:
table = self.service.tables[game.id]
for _i in range(2):
serial = game.getSerialInPosition()
game.callNraise(serial, game.serial2player[serial].money)
table.update()
for game in tourney.games:
for player in game.serial2player.itervalues():
if not player.money: user_serials_broke.append(player.serial)
disconnectBrokeClients()
# wait for players to be removed
d = defer.Deferred()
reactor.callLater(3, d.callback, True)
return d
def test_eap_tls_with_invalid_session_id(self):
df = defer.Deferred()
def eap_tls_invalid_session_id(df):
def tls_invalid_session_id_cb():
log_test.info(
'TLS authentication failed with invalid session id')
tls = TLSAuthTest(fail_cb=tls_invalid_session_id_cb,
session_id=12345,
session_id_length=1)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_invalid_session_id, df)
return df
def test_eap_tls_with_invalid_content_type(self, Positive_Test=True):
df = defer.Deferred()
def eap_tls_invalid_content_type(df):
def tls_invalid_content_type_cb():
log_test.info(
'TLS authentication failed with invalid content type in TLSContentType packet'
)
tls = TLSAuthTest(fail_cb=tls_invalid_content_type_cb,
invalid_content_type=24)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_invalid_content_type, df)
return df
def test_stats_with_collectd_get_mem_stats(self):
df = defer.Deferred()
def collectd_sample(df):
self.stat_option()
for controller in self.controllers:
if not controller:
continue
url_mem_stats = 'http://%s:8181/onos/cpman/controlmetrics/memory_metrics' % (
controller)
auth = ('karaf', 'karaf')
self.collectd_agent_metrics(controller, auth, url=url_mem_stats)
log.info('Successfully memory metrics are retained by the stats')
df.callback(0)
reactor.callLater(0, collectd_sample, df)
return df
def test_eap_tls_with_restart_of_radius_server(self):
df = defer.Deferred()
def eap_tls_restart_radius_server(df):
def tls_restart_radius_server_cb():
log_test.info(
'TLS authentication failed with radius server down in middle of authentication process'
)
tls = TLSAuthTest(fail_cb=tls_restart_radius_server_cb,
restart_radius=True)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_restart_radius_server, df)
return df
def test_eap_tls_with_invalid_record_fragment_length(self):
df = defer.Deferred()
def eap_tls_invalid_record_fragment_length(df):
def eap_tls_invalid_record_fragment_length_cb():
log_test.info(
'TLS authentication failed with invalid fragment length field in TLSRecord packet'
)
tls = TLSAuthTest(
fail_cb=eap_tls_invalid_record_fragment_length_cb,
record_fragment_length=17384)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_invalid_record_fragment_length, df)
return df
def firstRounds(status):
for game in tourney.games:
table = self.service.tables[game.id]
for _i in range(2):
serial = game.getSerialInPosition()
game.callNraise(serial, game.serial2player[serial].money)
table.update()
for game in tourney.games:
for player in game.serial2player.itervalues():
if not player.money:
user_serials_broke.append(player.serial)
disconnectBrokeClients()
# wait for players to be removed
d = defer.Deferred()
reactor.callLater(3, d.callback, True)
return d
def test_eap_tls_with_invalid_handshake_length_client_hello(self):
df = defer.Deferred()
def eap_tls_invalid_handshake_length_client_hello(df):
def tls_invalid_handshake_length_client_hello_cb():
log_test.info(
'TLS authentication failed with invalid handshake length in client hello packet'
)
tls = TLSAuthTest(
fail_cb=tls_invalid_handshake_length_client_hello_cb,
invalid_client_hello_handshake_length=True)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_invalid_handshake_length_client_hello, df)
return df
def test_eap_tls_clientkeyex_replace_with_serverkeyex(self):
df = defer.Deferred()
def eap_tls_clientkeyex_replace_with_serverkeyex(df):
def tls_clientkeyex_replace_with_serverkeyex_cb():
log_test.info(
'TLS authentication failed with client key exchange replaced with server key exchange'
)
tls = TLSAuthTest(
fail_cb=tls_clientkeyex_replace_with_serverkeyex_cb,
clientkeyex_replace_with_serverkeyex=True)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_clientkeyex_replace_with_serverkeyex, df)
return df
def test_eap_tls_with_aaa_app_deactivation(self):
df = defer.Deferred()
def eap_tls_aaa_app_deactivate(df):
def tls_aaa_app_deactivate_cb():
log_test.info(
'TLS authentication failed with aaa app deactivated in ONOS'
)
tls = TLSAuthTest(fail_cb=tls_aaa_app_deactivate_cb)
self.onos_ctrl.deactivate()
tls.runTest()
assert_equal(tls.failTest, True)
self.onos_ctrl.activate()
df.callback(0)
reactor.callLater(0, eap_tls_aaa_app_deactivate, df)
return df
def test_eap_tls_with_incorrect_cipher_suite_length_field(self):
df = defer.Deferred()
def eap_tls_incorrect_cipher_suite_length_field(df):
def tls_incorrect_cipher_suite_length_field_cb():
log_test.info(
'TLS authentication failed with incorrect cipher suite length field in client hello packet'
)
tls = TLSAuthTest(
fail_cb=tls_incorrect_cipher_suite_length_field_cb,
cipher_suites_length=0)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_incorrect_cipher_suite_length_field, df)
return df
def test_fabric(self):
"""Test the connectivity between the compute nodes"""
df = defer.Deferred()
def verify_fabric(df):
assert_not_equal(self.fabric, None)
failed_nodes = []
failed_nodes = self.fabric.ping_neighbors()
if failed_nodes:
log.info('Failed nodes: %s' % failed_nodes)
for node, neighbor, _ in failed_nodes:
log.info('Ping from node %s to neighbor %s Failed' %
(node, neighbor))
assert_equal(len(failed_nodes), 0)
df.callback(0)
reactor.callLater(0, verify_fabric, df)
return df
def test_eap_tls_with_invalid_id_in_client_hello_packet(self):
df = defer.Deferred()
def eap_tls_with_invalid_id_in_client_hello_packet(df):
def tls_with_invalid_id_in_client_hello_packet_cb():
log_test.info(
'TLS authentication failed with invalid id in client hello packet'
)
tls = TLSAuthTest(
fail_cb=tls_with_invalid_id_in_client_hello_packet_cb,
id_mismatch_in_client_hello_packet=True)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_with_invalid_id_in_client_hello_packet,
df)
return df
def test_eap_tls_with_incorrect_tlsrecord_certificate_request(self):
df = defer.Deferred()
def eap_tls_incorrect_tlsrecord_certificate_request(df):
def tls_incorrect_tlsrecord_certificate_request_cb():
log_test.info(
'TLS authentication failed with incorrect tlsrecord type in certificate request packet'
)
tls = TLSAuthTest(
fail_cb=tls_incorrect_tlsrecord_certificate_request_cb,
incorrect_tlsrecord_type_cert_req=True)
tls.runTest()
assert_equal(tls.failTest, True)
df.callback(0)
reactor.callLater(0, eap_tls_incorrect_tlsrecord_certificate_request,
df)
return df
def test_stats_with_collectd_plugin_and_onos_installation(self):
df = defer.Deferred()
def collectd_sample(df):
cmd = 'ls'
output = subprocess.check_output(cmd, shell=True)
if 'write_onos' in output:
log.info(
'Collectd is installed properly and plugin happend to ONOS'
)
pass
else:
log.info(
'Collectd is not installed properly and no plugin happend to ONOS'
)
assert_equal(False, True)
df.callback(0)
reactor.callLater(0, collectd_sample, df)
return df
def get_next_message(self, community, message_name):
def timeout(d):
deferreds = self.message_callbacks.get(community, {}).get(message_name, [])
if d in deferreds:
deferreds.remove(d)
d.errback(RuntimeError('get_next_message timeout'))
deferred = Deferred()
community.register_task(deferred, reactor.callLater(10, timeout, deferred))
self.message_callbacks[community] = self.message_callbacks.get(community, {})
self.message_callbacks[community][message_name] = self.message_callbacks.get(message_name, [])
self.message_callbacks[community][message_name].append(deferred)
return deferred
def DONTtest_set_multiple(self):
m = self.protocol.transport = MockTransport()
d1 = self.protocol.set("a", "1")
reactor.callLater(0, self.protocol.lineReceived, "STORED")
assert self.protocol.lock.locked
def wrote_1(key):
assert key == "a"
assert m.value() == '\r\n'.join(["set a 0 0 1", "1", ""])
m.buffer = []
assert self.protocol.lock.locked
reactor.callLater(0, self.protocol.lineReceived, "STORED")
d1.addCallback(wrote_1)
d2 = self.protocol.set("b", "2")
final_d = defer.Deferred()
def wrote_2(key):
assert key == "b"
assert m.value() == '\r\n'.join(["set b 0 0 1", "2", ""])
assert self.protocol.lock.locked
reactor.callLater(0, final_d.callback, None)
d2.addCallback(wrote_2)
def final(_):
assert not self.protocol.lock.locked
final_d.addCallback(final)
return final_d
def test02(self):
"lawl"
pokerservice.UPDATE_TOURNEYS_SCHEDULE_DELAY = 1
pokerservice.CHECK_TOURNEYS_SCHEDULE_DELAY = 0.1
cursor = self.db.cursor()
cursor.execute(
"INSERT INTO `tourneys_schedule` (`name`, `description_short`, `description_long`, `players_quota`, `variant`, `betting_structure`, `seats_per_game`, `currency_serial`, `buy_in`, `rake`, `sit_n_go`, `start_time`, `register_time`, `respawn`, `respawn_interval`, `players_min`, `breaks_first`)" \
"VALUES ('Only4', 'Sit and Go 6 players and only 4, Holdem', 'Sit and Go 4 players only', '4', 'holdem', 'level-15-30-no-limit', '2', 1, '0', '0', 'y', '0', '0', 'y', '0', '6', 100 )"
)
cursor.close()
self.service.startService()
self.service.delays['tourney_kick'] = 2
self.createUsers(4)
tourneys = self.service.tourneySelect('Only4')
self.assertEquals(len(tourneys), 1)
t = tourneys[0]
# by moving, a table gets destroyed
tourney_serial = t['serial']
clients = {}
for user_serial in self.user_serials:
clients[user_serial] = ClientMockup(user_serial)
self.service.avatar_collection.add(clients[user_serial])
self.service.tourneyRegister(PacketPokerTourneyRegister(serial=user_serial, tourney_serial=tourney_serial))
tourney = self.service.tourneys.values()[0]
user_serials_broke = []
d = defer.Deferred()
def disconnectBrokeClients():
for serial in user_serials_broke:
table = clients[serial].tables.itervalues().next()
table.disconnectPlayer(clients[serial])
def joinAll(status):
self.assertEquals(pokertournament.TOURNAMENT_STATE_RUNNING, tourney.state)
for game in tourney.games:
table = self.service.tables[game.id]
for serial in game.serial2player:
table.joinPlayer(clients[serial])
table.update()
return status
def firstRounds(status):
for game in tourney.games:
table = self.service.tables[game.id]
for _i in range(2):
serial = game.getSerialInPosition()
game.callNraise(serial, game.serial2player[serial].money)
table.update()
for game in tourney.games:
for player in game.serial2player.itervalues():
if not player.money: user_serials_broke.append(player.serial)
disconnectBrokeClients()
# wait for players to be removed
d = defer.Deferred()
reactor.callLater(3, d.callback, True)
return d
def secondRound(status):
self.assertEquals(len(tourney.games), 1)
self.assertEquals(len(tourney.games[0].playersAll()), 2)
d.addCallback(joinAll)
d.addCallback(firstRounds)
d.addCallback(secondRound)
reactor.callLater(3, d.callback, True)
return d
def sendPacket(self, packet):
self.packets.append(packet)
if self.deferred and self.type == packet.type:
reactor.callLater(0, lambda: self.deferred.callback(packet))
def wrote_2(key):
assert key == "b"
assert m.value() == '\r\n'.join(["set b 0 0 1", "2", ""])
assert self.protocol.lock.locked
reactor.callLater(0, final_d.callback, None)
def wrote_1(key):
assert key == "a"
assert m.value() == '\r\n'.join(["set a 0 0 1", "1", ""])
m.buffer = []
assert self.protocol.lock.locked
reactor.callLater(0, self.protocol.lineReceived, "STORED")
