def setUp(self):
''' Initializes class variables for test cases.'''
self.set_verbosity(0)
Configuration._cache.update(self.game_options)
self.variant = standard
opts = GameOptions()
self.params = opts.get_params()
self.level = opts.LVL
self.validator = Validator(opts.LVL)
self.player = None
self.replies = []
def test_map_define(self):
''' Test the creation of a new map from a simple MDF.'''
mdf = MDF(ENG, FRA)([
(ENG, EDI, LON),
(FRA, BRE, PAR),
([ENG, FRA], BEL, HOL),
(UNO, SPA, NWY),
], [ECH, NTH, PIC])(
(EDI, [AMY, LON], [FLT, NTH]),
(LON, [AMY, EDI], [FLT, NTH, ECH]),
(BRE, [AMY, PAR, PIC, SPA], [FLT, ECH, PIC, (SPA, NCS)]),
(PAR, [AMY, PAR, SPA, PIC]),
(BEL, [AMY, PIC, HOL], [FLT, NTH, ECH, PIC, HOL]),
(HOL, [AMY, BEL], [FLT, NTH]),
(SPA, [AMY, PAR, BRE], [(FLT, NCS), BRE]),
(NWY, [AMY], [FLT, NTH]),
(ECH, [FLT, NTH, BRE, LON, BEL, PIC]),
(NTH, [FLT, ECH, BEL, HOL, LON, NWY, EDI]),
(PIC, [AMY, BRE, PAR, BEL], [FLT, ECH, BRE, BEL]),
)
self.failIf(Validator().validate_server_message(mdf),
'Invalid MDF message')
m = Map(Variant('simplified'))
self.failIf(m.valid, 'Map valid before MDF')
result = m.define(mdf)
self.failIf(result, result)
def test_validate_option(self):
# Todo: Fix this test to actually test the client_opts option again.
self.connect_player(self.Test_Player)
validator = self.player.validator
self.player.validator = None
self.send(REJ(YES))
self.seek_reply(+HLO)
self.failIf(self.player.closed)
self.player.validator = validator or Validator()
self.send(REJ(YES))
self.failUnless(self.player.closed)
def setUp(self):
""" Initializes class variables for test cases."""
from twisted.internet import reactor
self.manager = ThreadManager(reactor)
Configuration._cache.update(self.game_options)
self.variant = standard
opts = GameOptions()
self.params = opts.get_params()
self.level = opts.LVL
self.validator = Validator(opts.LVL)
self.player = None
self.replies = []
def failUnlessValid(self, message):
result = Validator().validate_server_message(message)
self.failIf(result, result)
class PlayerTestCase(unittest.TestCase):
""" Basic Player Functionality"""
game_options = {
"LVL": 8000,
"PDA": True,
"variant": "standard",
"quit": True,
"host": "",
"send_SUB": False,
"send_ORD": False,
"draw": 3,
"response": "die",
}
def setUp(self):
""" Initializes class variables for test cases."""
from twisted.internet import reactor
self.manager = ThreadManager(reactor)
Configuration._cache.update(self.game_options)
self.variant = standard
opts = GameOptions()
self.params = opts.get_params()
self.level = opts.LVL
self.validator = Validator(opts.LVL)
self.player = None
self.replies = []
def handle_message(self, message):
reply = self.validator.validate_client_message(message)
self.failIf(reply, reply)
self.replies.append(message)
def tearDown(self):
if self.player:
self.send(+OFF)
def send(self, message):
self.player.handle_message(message)
def accept(self, message):
self.send(YES(message))
def reject(self, message):
self.send(REJ(message))
def connect_player(self, player_class, **kwargs):
self.player = player_class(manager=self.manager, **kwargs)
self.player.register(Transport(self), self.variant.rep)
return self.player
def send_hello(self, country=None):
self.send(HLO(country or ENG)(self.level)(self.params))
def seek_reply(self, message, error=None):
while self.replies:
msg = self.replies.pop(0)
if msg == message:
break
else:
self.fail(error or "Expected: " + str(message))
def start_game(self, now=None, sco=None, country=None):
while self.replies:
msg = self.replies.pop(0)
if msg[0] is NME:
self.accept(msg)
break
else:
self.fail("No NME message")
self.send(MAP(self.variant.mapname))
while self.replies:
msg = self.replies.pop(0)
if msg[0] is MDF:
self.send(self.variant.mdf())
elif msg[0] is YES and msg[2] is MAP:
break
else:
self.fail("Failed to accept the map")
self.send_hello(country)
self.send(sco or self.variant.sco())
self.send(now or self.variant.now())
def assertContains(self, item, series):
self.failUnless(item in series, "Expected %r among %r" % (item, series))
class PlayerTestCase(unittest.TestCase):
''' Basic Player Functionality'''
game_options = {
'LVL': 8000,
'PDA': True,
'variant' : 'standard',
'quit' : True,
'host' : '',
'send_SET': False,
'send_ORD': False,
'draw': 3,
'response': 'die',
}
def setUp(self):
''' Initializes class variables for test cases.'''
self.set_verbosity(0)
Configuration._cache.update(self.game_options)
self.variant = standard
opts = GameOptions()
self.params = opts.get_params()
self.level = opts.LVL
self.validator = Validator(opts.LVL)
self.player = None
self.replies = []
def handle_message(self, message):
#print message
reply = self.validator.validate_client_message(message)
self.failIf(reply, reply)
self.replies.append(message)
def tearDown(self):
if self.player: self.send(+OFF)
def set_verbosity(self, verbosity):
Configuration.set_globally('verbosity', verbosity)
def send(self, message): self.player.handle_message(message)
def accept(self, message): self.send(YES(message))
def reject(self, message): self.send(REJ(message))
def connect_player(self, player_class, **kwargs):
self.player = player_class(send_method=self.handle_message,
representation=self.variant.rep, **kwargs)
self.player.register()
self.player.threaded = []
def send_hello(self, country=None):
self.send(HLO(country or ENG)(self.level)(self.params))
def seek_reply(self, message, error=None):
while self.replies:
msg = self.replies.pop(0)
if msg == message: break
else: self.fail(error or 'Expected: ' + str(message))
def start_game(self):
while self.replies:
msg = self.replies.pop(0)
if msg[0] is NME: self.accept(msg); break
else: self.fail('No NME message')
self.send(MAP(self.variant.mapname))
while self.replies:
msg = self.replies.pop(0)
if msg[0] is MDF: self.send(self.variant.map_mdf)
elif msg[0] is YES and msg[2] is MAP: break
else: self.fail('Failed to accept the map')
self.send_hello()
self.send(self.variant.sco())
self.send(self.variant.now())
def assertContains(self, item, series):
self.failUnless(item in series, 'Expected %r among %r' % (item, series))
def test_HLO_PDA(self):
''' The HLO message should be valid with level 10 parameters.'''
self.connect_player(self.Test_Player)
if not self.player.validator: self.player.validator = Validator()
self.start_game()
self.failIf(self.player.closed)
def setUp(self):
self.validator = Validator(8000)
class ValidatorTestCase(unittest.TestCase):
def setUp(self):
self.validator = Validator(8000)
@fails
def test_short_draw(self):
message = DRW (ENG)
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, HUH (DRW, (ENG, ERR)))
def test_empty_mdf_uno(self):
message = MDF (ENG, FRA) ([(ENG, LON, EDI), (FRA, PAR, BRE), (UNO,)],
[WAL, ECH]) ([LON, (AMY, WAL), (FLT, ECH, WAL)],
[ECH, (FLT, LON, BRE)])
reply = self.validator.validate_server_message(message)
self.failUnlessEqual(reply, False)
def test_mistaken_prn(self):
message = SND (FRA) (PRP (SCD (ENG)))
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, HUH (SND (FRA) (PRP (SCD (ENG, ERR)))))
def test_invalid_encoding(self):
# ERR gets placed before the first undecodable character.
message = NME ("Tom\xe1s") ("v1.3")
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, HUH (NME ("Tom", ERR, "\xe1s") ("v1.3")))
def test_bignum_valid(self):
# Bignum tokens are valid number extensions
message = IAM (ENG) (123456)
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, False)
def test_bignum_invalid(self):
# Bignum tokens are not valid where a number is expected
bignum = protocol.default_rep[0x4C4C]
message = IAM (ENG) (bignum)
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, HUH (IAM (ENG) (ERR, bignum)))
def test_press_reply_reply(self):
# The standard press replies cannot be used to reply to replies.
response = YES (PRP (PCE (ENG, FRA)))
message = SND (FRA) (REJ (response))
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, HUH (SND (FRA) (REJ (ERR, response))))
@fails
def test_double_err_press(self):
# HUH press messages should be allowed to contain multiple ERR tokens.
press = PRP (AND (PCE (ENG, ERR, FRA)) (PCE (FRA, ERR, ENG)))
message = SND (FRA) (HUH (press))
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, False)
def test_missing_err_press(self):
# HUH press messages should be allowed to not contain an ERR token.
press = PRP (AND (PCE (ENG, FRA)) (PCE (FRA, ENG)))
message = SND (FRA) (HUH (press))
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, False)
def test_missing_err_invalid_press(self):
# HUH press messages should not contain invalid press without an ERR.
press = PRP (PCE (ENG, LON))
message = SND (FRA) (HUH (press))
reply = self.validator.validate_client_message(message)
self.failIfEqual(reply, False)
def test_missing_err_reply_press(self):
# HUH press replies to a reply should be allowed to not contain an ERR.
press = PRP (AND (PCE (ENG, FRA)) (PCE (FRA, ENG)))
message = SND (FRA) (HUH (YES (press)))
reply = self.validator.validate_client_message(message)
self.failUnlessEqual(reply, False)
