def should_start_and_stop():
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=snoop)
r = orb.init_cog(fn=receiver_cog_fake)
tcp_server_cog = orb.init_cog(fn=tcp_server_cog_new)
#
addr = '127.0.0.1'
port = 5000
password = '******'
#
# confirm starting state
orb.cycle()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid == None
#
# scenario: start the server
r.nc_start_service(ip=addr, port=port, password=password)
#
# confirm effects
assert tcp_server_cog.server_sid != None
assert tcp_server_cog.client_sid == None
#
# scenario: stop the service
stop_service(orb=orb)
#
# confirm effects
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid == None
#
return True
def should_throw_alg_exception_if_packet_seen_before_password():
engine = engine_fake()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# scenario: gruel_recv happens without a password having been set
b_error = False
try:
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_heartbeat_payload()))
except:
b_error = True
if b_error:
return True
else:
log('expected an exception, did not get one')
return False
def should_clear_state_in_announce_connect():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
r.nc_announce_tcp_connect(
ip='does not matter',
port=1234)
assert 1 == r.count_nearnote()
#
r.nc_announce_tcp_condrop()
assert 2 == r.count_nearnote()
#
return True
def __init__(self, engine, cb_doc_recv):
self.engine = engine
self.cb_doc_recv = cb_doc_recv
#
self.b_active = False
#
self.gruel_server_nearcast = nearcast_orb_new(
engine=self.engine,
nearcast_schema=gs_nearcast_schema_new())
#
self.tcp_server_cog = tcp_server_cog_new(
cog_h='tcp_server_cog',
orb=self.gruel_server_nearcast,
engine=engine)
self.gruel_server_nearcast.add_cog(
cog=self.tcp_server_cog)
#
self.uplink = UplinkCog(
cog_h='uplink',
orb=self.gruel_server_nearcast,
engine=engine)
self.gruel_server_nearcast.add_cog(
cog=self.uplink)
#
self.uplink.send_nearnote(
s='prop_gruel_server: nearcast_started')
def should_allow_authorised_ip():
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
nearcast_snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
nearcast_snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=nearcast_snoop)
r = orb.init_cog(fn=receiver_cog_fake)
ipval_cog = orb.init_cog(fn=ipval_cog_new)
#
ip = '127.0.0.1'
port = 5000
#
# scenario: we see permission for a differnt ip and then a connect
r.nc_ipval_add_ip(ip='203.15.93.2')
r.nc_announce_tcp_connect(ip=ip, port=port)
#
# check effects: we should still see a boot messaage
assert 1 == r.count_please_tcp_boot()
# but we do get a note to say it's ok
assert 0 == r.count_nearnote()
#
# scenario: now we permit the relevant ip, and then see a connect
r.nc_ipval_add_ip(ip=ip)
r.nc_announce_tcp_connect(ip=ip, port=port)
#
# check effects: we should see no more boot messages
assert 1 == r.count_please_tcp_boot()
# but we do get a note to say it's ok
assert 1 == r.count_nearnote()
#
return True
def should_store_password_values():
engine = engine_fake()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# scenario: password message
our_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# confirm effects
assert server_customs_cog.expected_password == our_password
#
return True
def should_send_gruel_send_data_to_a_connected_client():
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(gruel_schema=gruel_schema, mtu=MTU)
gruel_puff = gruel_puff_new(gruel_schema=gruel_schema, mtu=MTU)
#
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=snoop)
r = orb.init_cog(fn=receiver_cog_fake)
tcp_server_cog = orb.init_cog(fn=tcp_server_cog_new)
#
addr = '127.0.0.1'
port = 5000
password = '******'
#
# confirm starting state
assert 0 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid == None
#
# scenario: start the server
start_service(orb=orb, ip=addr, port=port, password=password)
#
# confirm effects
assert 0 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid != None
assert tcp_server_cog.client_sid == None
#
# scenario: client connects
client_addr = '203.15.93.150'
client_port = 6000
simulate_client_connect(engine=engine,
orb=orb,
tcp_server_cog=tcp_server_cog,
ip=client_addr,
port=client_port)
#
# confirm baseline
assert 1 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid != None
#
# scenario: tcp_server_cog gets gruel_send but client is not connected
r.nc_gruel_send(payload=gruel_press.create_client_login_payload(
password='******', heartbeat_interval=4))
orb.cycle()
#
# confirm effects: client should still be connected, and we should have
# sent no packets to the engine.
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid != None
assert 1 == len(engine.sent_data)
#
return True
def create_orb(engine):
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=nearcast_schema_new(i_nearcast=I_NEARCAST_SCHEMA))
orb.add_cog(cog=cog_gruel_server_new(name='server01',
engine=engine,
addr=TERM_LINK_ADDR,
port=TERM_LINK_PORT))
return orb
def should_run_a_rejection_sequence():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# start the service
our_password = '******'
usr_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# confirm effects: see a
assert 0 == clock.now()
#
# scenario: rejection is sequenced
server_customs_cog._to_rejection(
s='triggered by test')
#
# nothing should have changed
assert 0 == r.count_gruel_send()
assert 0 == r.count_please_tcp_boot()
#
# at three seconds we should see server_bye but no boot
clock.inc(3)
orb.cycle()
assert 1 == r.count_gruel_send()
d_gruel = gruel_puff.unpack(
payload=r.last_gruel_send())
assert d_gruel['message_h'] == 'server_bye'
assert 0 == r.count_please_tcp_boot()
#
# at four seconds we should see the boot
clock.inc(1)
orb.cycle()
assert 1 == r.count_please_tcp_boot()
#
return True
def should_handle_client_connect_and_then_boot_client():
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=snoop)
r = orb.init_cog(fn=receiver_cog_fake)
tcp_server_cog = orb.init_cog(fn=tcp_server_cog_new)
#
addr = '127.0.0.1'
port = 5000
password = '******'
#
# confirm starting state
assert 0 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid == None
#
# scenario: start the server
start_service(orb=orb, ip=addr, port=port, password=password)
#
# confirm effects
assert 0 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid != None
assert tcp_server_cog.client_sid == None
#
# scenario: client connects
client_addr = '203.15.93.150'
client_port = 6000
simulate_client_connect(engine=engine,
orb=orb,
tcp_server_cog=tcp_server_cog,
ip=client_addr,
port=client_port)
#
# confirm effects
assert 1 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid != None
#
# scenario: stop the service, booting the client in the process
stop_service(orb=orb)
#
# confirm effects
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid == None
#
return True
def should_boot_client_when_invalid_gruel_is_received():
activity = activity_new()
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=snoop)
#
r = orb.init_cog(fn=receiver_cog_fake)
tcp_server_cog = orb.init_cog(fn=tcp_server_cog_new)
#
addr = '127.0.0.1'
port = 5000
password = '******'
#
# get to a point where the client is logged in
start_service(orb=orb, ip=addr, port=port, password=password)
simulate_client_connect(engine=engine,
orb=orb,
tcp_server_cog=tcp_server_cog,
ip=addr,
port=port)
#
# confirm starting position
assert 1 == r.count_announce_tcp_connect()
assert 0 == r.count_please_tcp_boot()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid != None
#
# scenario: send invalid data as though it is gruel
cs_tcp_recv = CsTcpRecv()
cs_tcp_recv.engine = engine
cs_tcp_recv.client_sid = create_sid()
cs_tcp_recv.data = bytes('this string is invalid gruel', 'utf8')
tcp_server_cog._engine_on_tcp_recv(cs_tcp_recv=cs_tcp_recv)
orb.cycle()
#
# confirm effects: nearcast a boot message
assert 1 == r.count_please_tcp_boot()
assert tcp_server_cog.server_sid != None
assert tcp_server_cog.client_sid == None
#
return True
def main():
init_logging()
engine = engine_new()
try:
nearcast_schema = nearcast_schema_new(
i_nearcast=I_NEARCAST_SCHEMA)
nearcast_snoop = nearcast_snoop_new(
engine=engine,
nearcast_schema=nearcast_schema,
addr=TAP_ADDR,
port=TAP_PORT)
#
nearcast_orb = nearcast_orb_new(
engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=nearcast_snoop)
nearcast_orb.add_cog(
cog=cog_console_new(
cog_h='console01',
nearcast_orb=nearcast_orb,
engine=engine,
addr=CONSOLE_ADDR,
port=CONSOLE_PORT))
nearcast_orb.add_cog(
cog=CogEventSource(
cog_h='esource01',
nearcast_orb=nearcast_orb,
engine=engine))
nearcast_orb.add_cog(
cog=cog_gruel_client_new(
cog_h='client01',
nearcast_orb=nearcast_orb,
engine=engine,
addr=TERM_LINK_ADDR,
port=TERM_LINK_PORT))
engine.add_orb(
orb=nearcast_orb)
engine.event_loop()
except KeyboardInterrupt:
pass
except:
traceback.print_exc()
finally:
engine.close()
def should_do_basic_login_reject():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# start the service
our_password = '******'
usr_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# check starting position
assert 0 == r.count_please_tcp_boot()
#
# scenario: user sends an invalid password
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_client_login_payload(
password=usr_password,
heartbeat_interval=3)))
orb.cycle()
#
# check effects: we should boot the client
assert server_customs_cog.state == ServerCustomsState.reject_stage_a
assert 0 == r.count_gruel_send()
#
return True
def should_do_successful_login_accept():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# start the service
our_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# scenario: user sends an valid password
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_client_login_payload(
password=our_password,
heartbeat_interval=3)))
orb.cycle()
#
# confirm effects
assert server_customs_cog.state == ServerCustomsState.authorised
assert 1 == r.count_announce_login()
assert 1 == r.count_gruel_send()
d_grual = gruel_puff.unpack(r.last_gruel_send())
assert d_grual['message_h'] == 'server_greet'
#
return True
def should_reject_unauthorised_ip():
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
nearcast_snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
nearcast_snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=nearcast_snoop)
r = orb.init_cog(fn=receiver_cog_fake)
ipval_cog = orb.init_cog(fn=ipval_cog_new)
#
# scenario: unauth ip connects
ip = '127.0.0.1'
port = 5000
r.nc_announce_tcp_connect(ip=ip, port=port)
#
# check effects: we should send a messaage to boot
assert 1 == r.count_please_tcp_boot()
#
return True
def should_allow_any_ip():
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
nearcast_snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
nearcast_snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=nearcast_snoop)
r = orb.init_cog(fn=receiver_cog_fake)
ipval_cog = orb.init_cog(fn=ipval_cog_new)
#
ip = '127.0.0.1'
port = 5000
r.nc_ipval_disable()
r.nc_announce_tcp_connect(ip=ip, port=port)
#
assert 0 == r.count_please_tcp_boot()
assert 1 == r.count_nearnote()
#
return True
def should_boot_user_on_receipt_of_login_message_when_already_logged_in():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# start the service
our_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# hack the starting position
server_customs_cog.state = ServerCustomsState.authorised
#
# scenario: send a message that is client_login
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_client_login_payload(
password=our_password,
heartbeat_interval=3)))
orb.cycle()
#
# check effects
assert server_customs_cog.state == ServerCustomsState.reject_stage_a
#
return True
def should_boot_client_if_first_message_is_not_client_login():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# start the service
our_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# check starting position
assert 0 == r.count_please_tcp_boot()
#
# scenario: first message is not client_login
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_heartbeat_payload()))
orb.cycle()
#
# check effects
assert server_customs_cog.expected_password == our_password
#
return True
def should_boot_client_when_told_to():
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=snoop)
#
r = orb.init_cog(fn=receiver_cog_fake)
tcp_server_cog = orb.init_cog(fn=tcp_server_cog_new)
#
addr = '127.0.0.1'
port = 5000
password = '******'
#
# get to a point where the client is logged in
start_service(orb=orb, ip=addr, port=port, password=password)
simulate_client_connect(engine=engine,
orb=orb,
tcp_server_cog=tcp_server_cog,
ip=addr,
port=port)
#
# confirm starting position
assert 1 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid != None
#
# scenario: we receive a boot message
r.nc_please_tcp_boot()
#
# check effects: we want to see that the connection has been dropped and
# that the server is back up
assert tcp_server_cog.server_sid != None
assert tcp_server_cog.client_sid == None
#
return True
def should_buffer_a_couple_of_docs():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# start the service
our_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# preparation: user logs in
r.nc_announce_tcp_connect(
ip='also not important',
port=456)
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_client_login_payload(
password=our_password,
heartbeat_interval=3)))
orb.cycle()
#
# scenario: user sends part of a doc
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_docdata_payload(
b_complete=0,
data='123')))
orb.cycle()
#
# confirm effects (doc is not complete, so should be no effects)
assert 0 == r.count_doc_recv()
#
# scenario: now finish the first doc
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_docdata_payload(
b_complete=1,
data='456')))
orb.cycle()
#
# confirm effects (doc is not complete, so should be no effects)
assert 1 == r.count_doc_recv()
assert r.last_doc_recv() == '123456'
#
# scenario: now send a second doc, and check it's correct
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_docdata_payload(
b_complete=1,
data='here is a doc')))
orb.cycle()
#
# confirm effects
assert 2 == r.count_doc_recv()
assert r.last_doc_recv() == 'here is a doc'
#
return True
def should_broadcast_incoming_message_as_gruel_in():
engine = engine_fake()
nearcast_schema = gs_nearcast_schema_new()
snoop = nearcast_snoop_fake(nearcast_schema=nearcast_schema)
snoop.disable()
orb = nearcast_orb_new(engine=engine,
nearcast_schema=nearcast_schema,
nearcast_snoop=snoop)
#
r = orb.init_cog(fn=receiver_cog_fake)
tcp_server_cog = orb.init_cog(fn=tcp_server_cog_new)
#
addr = '127.0.0.1'
port = 5000
password = '******'
#
# get to a point where the client is logged in
start_service(orb=orb, ip=addr, port=port, password=password)
simulate_client_connect(engine=engine,
orb=orb,
tcp_server_cog=tcp_server_cog,
ip=addr,
port=port)
#
# confirm starting position
assert 1 == r.count_announce_tcp_connect()
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid != None
#
# scenario: client sends a message
client_send_password = '******'
client_send_hbint = 3
simulate_client_send_login(engine=engine,
orb=orb,
tcp_server_cog=tcp_server_cog,
pw=client_send_password,
hbint=client_send_hbint)
#
# confirm effects
assert 1 == r.count_gruel_recv()
d_gruel = r.last_gruel_recv()
assert d_gruel['message_h'] == 'client_login'
assert d_gruel['heartbeat_interval'] == client_send_hbint
assert d_gruel['password'] == client_send_password
#
# scenario: client disconnect
simulate_client_condrop(engine=engine,
orb=orb,
tcp_server_cog=tcp_server_cog)
#
# confirm effects
assert tcp_server_cog.server_sid != None
assert tcp_server_cog.client_sid == None
#
# scenario: close server
stop_service(orb=orb)
#
# confirm effects
assert tcp_server_cog.server_sid == None
assert tcp_server_cog.client_sid == None
#
return True
def should_send_a_couple_of_docs():
engine = engine_fake()
clock = engine.get_clock()
gruel_schema = gruel_schema_new()
gruel_press = gruel_press_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
gruel_puff = gruel_puff_new(
gruel_schema=gruel_schema,
mtu=engine.mtu)
#
orb = nearcast_orb_new(
engine=engine,
nearcast_schema=gs_nearcast_schema_new())
server_customs_cog = orb.init_cog(
fn=server_customs_cog_new)
r = orb.init_cog(
fn=receiver_cog_fake)
#
# start the service
our_password = '******'
r.nc_start_service(
ip='does not matter',
port=1234,
password=our_password)
#
# preparation: user logs in
r.nc_announce_tcp_connect(
ip='also not important',
port=456)
r.nc_gruel_recv(
d_gruel=gruel_puff.unpack(
payload=gruel_press.create_client_login_payload(
password=our_password,
heartbeat_interval=3)))
orb.cycle()
#
# confirm assumptions
assert 1 == r.count_gruel_send()
#
# scenario: we send a large outbound document towards customs
doc = '/'.join( ['x', 'y'*2000, 'z'] )
r.nc_doc_send(
doc=doc)
#
# confirm effects: expect to see the doc broken up into several pieces
assert 2 <= r.count_gruel_send()
# examine first doc packet
d_gruel = gruel_puff.unpack(r.get_gruel_send()[1])
assert d_gruel['message_h'] == 'docdata'
assert d_gruel['b_complete'] == 0
assert d_gruel['data'][0] == 'x'
# examine next-to-last doc packet
d_gruel = gruel_puff.unpack(r.get_gruel_send()[-2])
assert d_gruel['message_h'] == 'docdata'
assert d_gruel['b_complete'] == 0
assert d_gruel['data'][-1] == 'y'
# examine last doc packet
d_gruel = gruel_puff.unpack(r.get_gruel_send()[-1])
assert d_gruel['message_h'] == 'docdata'
assert d_gruel['b_complete'] == 1
assert d_gruel['data'][-1] == 'z'
#
return True
