def test_not():
""" Tests the NOT response """
daide_str = 'NOT ( CCD ( FRA ) )'
response_daide_str = 'CCD ( FRA )'
response = responses.NOT(response_bytes=str_to_bytes(response_daide_str))
assert isinstance(response, responses.NOT), 'Expected a NOT response'
assert bytes(response) == str_to_bytes(daide_str)
def test_yes():
""" Tests the YES response """
daide_str = 'YES ( TME ( #60 ) )'
request_daide_str = 'TME ( #60 )'
response = responses.YES(request_bytes=str_to_bytes(request_daide_str))
assert isinstance(response, responses.YES), 'Expected a YES response'
assert bytes(response) == str_to_bytes(daide_str)
def test_rej():
""" Tests the REJ response """
daide_str = 'REJ ( TME ( #60 ) )'
request_daide_str = 'TME ( #60 )'
response = responses.REJ(request_bytes=str_to_bytes(request_daide_str))
assert isinstance(response, responses.REJ), 'Expected a REJ response'
assert bytes(response) == str_to_bytes(daide_str)
def test_mdf():
""" Test the MDF request """
daide_str = 'MDF'
expected_str = 'MDF'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.MDF), 'Expected a MDF request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
def test_now():
""" Test the NOW request """
daide_str = 'NOW'
expected_str = 'NOW'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.NOW), 'Expected a NOW request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
def test_thx_001():
""" Tests the THX response """
daide_str = 'THX ( ( ENG FLT NWG ) SUP ( ENG AMY YOR ) MTO NWY ) ( MBV )'
order_daide_str = '( ( ENG FLT NWG ) SUP ( ENG AMY YOR ) MTO NWY )'
response = responses.THX(order_bytes=str_to_bytes(order_daide_str),
results=[])
assert isinstance(response, responses.THX), 'Expected a THX response'
assert bytes(response) == str_to_bytes(daide_str)
def test_obs():
""" Test the OBS request """
daide_str = 'OBS'
expected_str = 'OBS'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.OBS), 'Expected a OBS request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
def test_sco():
""" Test the SCO request """
daide_str = 'SCO'
expected_str = 'SCO'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SCO), 'Expected a SCO request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
def test_hst_spr():
""" Tests the HST request """
daide_str = 'HST ( SPR #1901 )'
expected_str = 'HST (SPR 1901)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.HST), 'Expected a HST request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == 'S1901M'
def test_thx_003():
""" Tests the THX response """
daide_str = 'THX ( ( ENG FLT NWG ) SUP ( ENG AMY YOR ) MTO NWY ) ( MBV )'
order_daide_str = '( ( ENG FLT NWG ) SUP ( ENG AMY YOR ) MTO NWY )'
response = responses.THX(
order_bytes=str_to_bytes(order_daide_str),
results=[error.code for error in [OK, err.MAP_LEAST_TWO_POWERS]])
assert isinstance(response, responses.THX), 'Expected a THX response'
assert bytes(response) == str_to_bytes(daide_str)
def test_drw_001():
""" Test the DRW request """
daide_str = 'DRW'
expected_str = 'DRW'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.DRW), 'Expected a DRW request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.powers == []
def test_huh_sub():
""" Tests the HUH request """
daide_str = 'HUH ( )'
expected_str = 'HUH ()'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.HUH), 'Expected a HUH request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.message_bytes == b''
def test_drw_002():
""" Test the DRW request """
daide_str = 'DRW ( FRA ENG ITA )'
expected_str = 'DRW (FRA ENG ITA)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.DRW), 'Expected a DRW request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.powers == ['FRANCE', 'ENGLAND', 'ITALY']
def test_yes():
""" Tests the YES request """
daide_str = 'YES ( MAP ( s t a n d a r d ) )'
expected_str = 'YES (MAP (standard))'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.YES), 'Expected a YES request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert tokens.Token(from_bytes=request.response_bytes[:2]) == tokens.MAP
def test_rej():
""" Tests the REJ request """
daide_str = 'REJ ( SVE ( g a m e n a m e ) )'
expected_str = 'REJ (SVE (gamename))'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.REJ), 'Expected a REJ request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert tokens.Token(from_bytes=request.response_bytes[:2]) == tokens.SVE
def test_adm():
""" Tests the ADM request """
daide_str = 'ADM ( I \' m h a v i n g c o n n e c t i o n p r o b l e m s )'
expected_str = 'ADM (I\'m having connection problems)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.ADM), 'Expected a ADM request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.adm_message == 'I\'m having connection problems'
def test_tme_sec():
""" Tests the TME request """
daide_str = 'TME ( #60 )'
expected_str = 'TME (60)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.TME), 'Expected a TME request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.seconds == 60
def test_not_drw():
""" Tests the NOT request """
daide_str = 'NOT ( DRW )'
expected_str = 'NOT (DRW)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.NOT), 'Expected a NOT request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert isinstance(request.request,
requests.DRW), 'Expected a DRW not request'
def test_not_tme_sec():
""" Tests the NOT request """
daide_str = 'NOT ( TME ( #60 ) )'
expected_str = 'NOT (TME (60))'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.NOT), 'Expected a NOT request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert isinstance(request.request,
requests.TME), 'Expected a TME not request'
def test_nme_001():
""" Tests the NME request """
daide_str = 'NME ( A l b e r t ) ( v 6 . 0 . 1 )'
expected_str = 'NME (Albert) (v6.0.1)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.NME), 'Expected a NME request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.client_name == 'Albert'
assert request.client_version == 'v6.0.1'
def test_iam():
""" Test the IAM request """
daide_str = 'IAM ( FRA ) ( #1234 )'
expected_str = 'IAM (FRA) (1234)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.IAM), 'Expected a IAM request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.power_name == 'FRANCE'
assert request.passcode == '1234'
def test_nme_002():
""" Tests the NME request """
daide_str = 'NME ( J o h n D o e ) ( v 1 . 2 )'
expected_str = 'NME (JohnDoe) (v1.2)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.NME), 'Expected a NME request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.client_name == 'JohnDoe'
assert request.client_version == 'v1.2'
def test_snd_004():
""" Tests the SND request """
daide_str = 'SND ( FRA ENG ) ( FCT ( PCE ( FRA ENG GER ) ) )'
expected_str = 'SND (FRA ENG) (FCT (PCE (FRA ENG GER)))'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SND), 'Expected a SND request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.powers == ['FRANCE', 'ENGLAND']
assert request.message_bytes == str_to_bytes('FCT ( PCE ( FRA ENG GER ) )')
def test_sub_convoy_002():
""" Tests the SUB request """
daide_str = 'SUB ( ( ITA FLT EAS ) CVY ( ITA AMY TUN ) CTO SYR )'
expected_str = 'SUB ((ITA FLT EAS) CVY (ITA AMY TUN) CTO SYR)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SUB), 'Expected a SUB request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.power_name == 'ITALY'
assert request.orders == ['F EAS C A TUN - SYR']
def test_sub_waive():
""" Tests the SUB request """
daide_str = 'SUB ( ENG WVE )'
expected_str = 'SUB (ENG WVE)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SUB), 'Expected a SUB request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.power_name == 'ENGLAND'
assert request.orders == ['WAIVE']
def test_sub_build():
""" Tests the SUB request """
daide_str = 'SUB ( ( ITA FLT NAP ) BLD )'
expected_str = 'SUB ((ITA FLT NAP) BLD)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SUB), 'Expected a SUB request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.power_name == 'ITALY'
assert request.orders == ['F NAP B']
def test_sub_retreat_coast():
""" Tests the SUB request """
daide_str = 'SUB ( ( ENG FLT LON ) RTO ( STP NCS ) )'
expected_str = 'SUB ((ENG FLT LON) RTO (STP NCS))'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SUB), 'Expected a SUB request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.power_name == 'ENGLAND'
assert request.orders == ['F LON R STP/NC']
def test_sub_convoy_003():
""" Tests the SUB request """
daide_str = 'SUB ( ( ENG FLT NTH ) CVY ( ENG AMY YOR ) CTO STP )'
expected_str = 'SUB ((ENG FLT NTH) CVY (ENG AMY YOR) CTO STP)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SUB), 'Expected a SUB request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.power_name == 'ENGLAND'
assert request.orders == ['F NTH C A YOR - STP']
def test_sub_remove():
""" Tests the SUB request """
daide_str = 'SUB ( ( RUS FLT GOB ) REM )'
expected_str = 'SUB ((RUS FLT GOB) REM)'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SUB), 'Expected a SUB request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.power_name == 'RUSSIA'
assert request.orders == ['F BOT D']
def test_sub_move_via_002():
""" Tests the SUB request """
daide_str = 'SUB ( ( ENG AMY YOR ) CTO NWY VIA ( NTH ) )'
expected_str = 'SUB ((ENG AMY YOR) CTO NWY VIA (NTH))'
request = RequestBuilder.from_bytes(str_to_bytes(daide_str))
assert isinstance(request, requests.SUB), 'Expected a SUB request'
assert bytes(request) == str_to_bytes(daide_str)
assert str(request) == expected_str
assert request.phase == ''
assert request.power_name == 'ENGLAND'
assert request.orders == ['A YOR - NWY VIA']
