def test_unsubscribe_and_subscribe_again(nsproxy, socket_type):
"""
Test resubscribing to topics after unsubscribing works fine.
"""
server = run_agent('server', base=ServerNumbers)
client = run_agent('client')
addr = server.bind(socket_type, alias='pub', handler=append_received)
client.set_attr(received=[])
client.connect(addr, alias='sub', handler=append_received)
# Establish a connection
server.each(0.1, 'send', 'pub', 'connecting...', alias='tmp')
assert wait_agent_attr(client, data='connecting...')
server.stop_timer('tmp')
# Subscribe to two topics
client.unsubscribe('sub', '')
client.subscribe('sub', handler={'negate': receive_negate,
'normal': append_received})
# Make server to start publishing messages
server.each(0.1, 'publish')
assert wait_agent_condition(client, match_tail, [-1, 2] * 4)
# Unsubscribe from one topic
client.unsubscribe('sub', 'negate')
assert wait_agent_condition(client, match_tail, [2] * 8)
# Subscribe again
client.subscribe('sub', handler={'negate': receive_negate})
assert wait_agent_condition(client, match_tail, [-1, 2] * 4)
def test_yield(nsproxy):
"""
REQ-REP pattern using a handler that yields a value. This is useful in
order to generate an early reply.
"""
def reply_early(agent, message):
yield message
time.sleep(agent.delay)
agent.delay = 'ok'
delay = 1
a0 = run_agent('a0')
a0.set_attr(delay=delay)
a1 = run_agent('a1')
addr = a0.bind('REP', handler=reply_early)
a1.connect(addr, alias='request')
t0 = time.time()
response = a1.send_recv('request', 'Working!')
assert time.time() - t0 < delay / 2.
assert response == 'Working!'
assert a0.get_attr('delay') == delay
# Sleep so that the replier has had time to update
time.sleep(delay + 0.5)
assert a0.get_attr('delay') == 'ok'
def test_resubscribe(nsproxy, socket_type):
"""
After subscribing to the same topic with a different handler after a
subscription to that topic was already made, we should override the
original handler.
Note that we will only override explicitly given topics (previous
subscriptions of other topics will remain untouched).
"""
server = run_agent('server', base=ServerNumbers)
client = run_agent('client')
addr = server.bind(socket_type, alias='pub', handler=append_received)
client.set_attr(received=[])
client.connect(addr, alias='sub', handler=append_received)
# Establish a connection
server.each(0.1, 'send', 'pub', 'connecting...', alias='tmp')
assert wait_agent_attr(client, data='connecting...')
server.stop_timer('tmp')
# Subscribe to two topics
client.unsubscribe('sub', '')
client.subscribe('sub', handler={'negate': receive_negate,
'normal': append_received})
server.each(0.1, 'publish')
assert wait_agent_condition(client, match_tail, [-1, 2] * 4)
# Resubscribe, so as to store the 'normal' (2) messages negated
client.subscribe('sub', handler={'normal': receive_negate})
assert wait_agent_condition(client, match_tail, [-1, -2] * 4)
def test_agent_dies(nsproxy):
"""
The function `agent_dies` should return `False` if the agent does not die
after a timeout.
"""
run_agent('a0')
assert not agent_dies('a0', nsproxy, timeout=0.5)
def test_sync_pub_send_handlers(nsproxy, handler, check_function,
should_crash):
"""
The handler for the requests MUST be specified in the `send` call.
It can be specified in different ways: method, functions...
"""
server = run_agent('server', base=ServerSyncPub)
client = run_agent('client', base=ClientWithHandler)
addr = server.addr('publish')
# Use an alternative handler so as to guarantee connection is established
client.connect(addr, alias='sub', handler='alternative_receive')
server.each(0.01, 'publish')
assert wait_agent_attr(client, name='alternative_received', length=2,
data='publication!')
if should_crash:
with pytest.raises(ValueError):
client.send('sub', 'request!')
else:
client.send('sub', 'request!', handler=handler)
assert wait_agent_attr(client, length=1)
if check_function:
# Check that the function was not stored as a method for the object
with pytest.raises(AttributeError) as error:
assert client.get_attr('append_received')
assert 'object has no attribute' in str(error.value)
def test_subscribe(nsproxy, socket_type, subscribe_separately):
"""
Test subscribing to various topics/handlers works fine.
"""
server = run_agent('server', base=ServerNumbers)
client = run_agent('client')
addr = server.bind(socket_type, alias='pub', handler=append_received)
client.set_attr(received=[])
client.connect(addr, alias='sub', handler=append_received)
# Establish a connection
server.each(0.1, 'send', 'pub', 'connecting...', alias='tmp')
assert wait_agent_attr(client, data='connecting...')
server.stop_timer('tmp')
# Subscribe to two topics. Client should only receive -1 and 2.
client.unsubscribe('sub', '')
if subscribe_separately:
client.subscribe('sub', handler={'negate': receive_negate})
client.subscribe('sub', handler={'normal': append_received})
else:
client.subscribe('sub', handler={'negate': receive_negate,
'normal': append_received})
server.each(0.1, 'publish')
assert wait_agent_condition(client, match_tail, [-1, 2] * 4)
def async_client_server(server_handler=blocked_reply):
server = run_agent('server', base=Server)
client = run_agent('client', base=Client)
addr = server.bind('ASYNC_REP', alias='replier', handler=server_handler)
client.connect(addr, alias='async', handler=append_received)
return (client, server)
def test_nameserver_proxy_shutdown_agents(nsproxy):
"""
Shutdown agents registered in a name server from a name server proxy.
"""
run_agent('Agent0', nsaddr=nsproxy.addr())
run_agent('Agent1', nsaddr=nsproxy.addr())
nsproxy.shutdown_agents()
assert len(nsproxy.agents()) == 0
def setup_busy_worker(nsproxy):
worker = run_agent('worker', base=BusyWorker)
boss = run_agent('boss')
boss.connect(worker.addr('pull'), alias='push')
# Make worker busy for 2 seconds
boss.send('push', 2)
assert wait_agent_attr(worker, name='busy', value=True, timeout=.5)
return worker
def test_nameserver_proxy_shutdown_with_agents():
"""
Shutdown a name server from a name server proxy.
"""
ns = run_nameserver()
run_agent('Agent0', nsaddr=ns.addr())
run_agent('Agent1', nsaddr=ns.addr())
ns.shutdown()
def test_agent_proxy_wait_running_0_seconds(nsproxy):
"""
Using `wait_for_running` on a proxy after initialization should block until
the agent is running or time out.
"""
run_agent('agent')
proxy = Proxy('agent').wait_for_running(timeout=0)
assert proxy.ping() == 'pong'
def test_run_agents_same_name(nsproxy):
"""
Check that the user cannot create two agents with the same name. A
RuntimeError should be raised.
"""
run_agent('name')
with pytest.raises(RuntimeError) as error:
run_agent('name')
assert 'name already registered' in str(error.value)
def test_agent_run_agent_safe_and_unsafe(nsproxy):
"""
Using the `run_agent` function should allow us to set a `safe` attribute
for the returned Proxy as well.
"""
safe = run_agent('a0', safe=True)
unsafe = run_agent('a1', safe=False)
assert safe._safe
assert not unsafe._safe
def test_nameserver_proxy_list(nsproxy):
"""
Verify new agents get registered in the nameserver.
"""
run_agent('a0', nsproxy.addr())
run_agent('a1', nsproxy.addr())
# List registered agents
agent_list = nsproxy.list()
assert 'a0' in agent_list
assert 'a1' in agent_list
def test_lambda(nsproxy):
"""
REQ-REP pattern using a lambda handler.
"""
a0 = run_agent('a0')
a1 = run_agent('a1')
addr = a0.bind('REP', handler=lambda agent, message: 'x' + message)
a1.connect(addr, alias='request')
response = a1.send_recv('request', 'Hello world')
assert response == 'xHello world'
def test_pushpull(nsproxy, serializer, message):
"""
Simple push-pull pattern test, using different serializations.
"""
a0 = run_agent('a0')
a1 = run_agent('a1')
a1.set_attr(received=None)
addr = a1.bind('PULL', handler=set_received, serializer=serializer)
a0.connect(addr, 'push')
a0.send('push', message)
assert wait_agent_attr(a1, name='received', value=message)
def test_nameserver_agent_address(nsproxy):
"""
A name server proxy can be used to retrieve an agent's socket address as
well, given the agent's alias and the socket's alias.
"""
a0 = run_agent('a0')
a1 = run_agent('a1')
addr0 = a0.bind('PUB', alias='foo')
addr1 = a1.bind('PUSH', alias='bar')
assert nsproxy.addr('a0', 'foo') == addr0
assert nsproxy.addr('a1', 'bar') == addr1
def test_nameserver_proxy_shutdown_raise_timeout():
"""
A name server proxy should raise a TimeoutError if agents were not shutdown
or killed before the set timeout.
"""
ns = run_nameserver()
run_agent('a0')
with pytest.raises(TimeoutError) as error:
ns.shutdown(timeout=0.)
assert 'not shutdown after' in str(error.value)
ns.shutdown()
def test_nameserver_environ(nsproxy):
"""
When starting a nameserver, a environment variable should be set to ease
the process of running new agents.
"""
assert str(nsproxy.addr()) == os.environ.get('OSBRAIN_NAMESERVER_ADDRESS')
run_agent('a0')
run_agent('a1')
# List registered agents
agent_list = nsproxy.list()
assert 'a0' in agent_list
assert 'a1' in agent_list
def test_simple_pub_dict_handler(nsproxy, server):
"""
SYNC_PUB should work just like a normal PUB. This test checks normal
behavior when using multiple handlers (i.e.: filtering).
When clients connect to a SYNC_PUB server, as long as they do not make
requests, this communication pattern should behave exactly like a normal
PUB-SUB pattern.
"""
server = run_agent('server', base=server)
both = run_agent('both', base=Client)
positive = run_agent('positive', base=Client)
bytestopic = run_agent('bytestopic', base=Client)
# Connect clients
addr = server.addr('publish')
addr_both = both.connect(addr, handler={'positive': append_received,
'negative': append_received})
addr_positive = positive.connect(addr,
handler={'positive': append_received})
addr_bytestopic = bytestopic.connect(addr,
handler={b'\xeb': append_received})
assert addr_both == addr.twin()
assert addr_positive == addr.twin()
assert addr_bytestopic == addr.twin()
# Publish from server
server.each(0, 'publish_str')
# Wait for clients to receive some data
n = 10
assert wait_agent_attr(both, length=n)
assert wait_agent_attr(positive, length=n)
assert wait_agent_attr(bytestopic, length=n)
# both
received = [int(x) for x in both.get_attr('received')]
assert len(received) >= n
for i in range(1, len(received)):
if received[i] > 0:
assert received[i - 1] == 1 - received[i]
else:
assert received[i - 1] == -received[i]
# positive
received = [int(x) for x in positive.get_attr('received')]
assert len(received) >= n
assert received == list(range(received[0], received[-1] + 1))
# bytestopic
received = bytestopic.get_attr('received')
assert len(received) >= n
assert all(x == 'bytes...' for x in received)
def test_unsubscribe_various(nsproxy, socket_type):
"""
Test that unsubscribing from various topics works fine.
The server will be publishing zeroes through two topics quickly, and
ones through a single topic slowly.
A subscriber will subscribe to all numbers, and then unsubscribe from the
topics related to the zeroes, therefore receiving three (or more) ones in
a row.
"""
def check_sum_three(agent):
"""
Check whether the last three received numbers sum to three.
For this test in particular, the last three numbers should be one,
received through the 'one' topic.
"""
return sum(agent.received[-3:]) == 3
def publish_zeroes(agent):
agent.send('pub', 0, topic='zero')
agent.send('pub', 0, topic='other_zero')
def publish_one(agent):
agent.send('pub', 1, topic='one')
# Set up the agents
server = run_agent('server')
client = run_agent('client', base=Client)
addr = server.bind(socket_type, alias='pub', handler=append_received)
client.connect(addr, alias='sub', handler={'zero': append_received,
'other_zero': append_received,
'one': append_received})
# Make sure the connection is established
server.each(0.1, 'send', 'pub', 'connecting...', topic='zero', alias='tmp')
assert wait_agent_attr(client, data='connecting...')
server.stop_timer('tmp')
# Wait until client receives some numbers
client.set_attr(received=[])
server.each(0.1, publish_zeroes)
server.each(0.2, publish_one)
assert wait_agent_attr(client, length=5)
assert not client.execute_as_method(check_sum_three)
# Unsubscribe from zeroes numbers (receiving only ones)
client.unsubscribe('sub', ('zero', 'other_zero'))
assert wait_agent_condition(client, check_sum_three)
def test_agent_proxy_initialization_timeout(nsproxy):
"""
An agent proxy should raise a TimeoutError at initialization if the agent
is not ready after a number of seconds.
"""
class InitTimeoutProxy(Proxy):
def ping(self):
time.sleep(0.1)
raise TimeoutError()
run_agent('foo')
with pytest.raises(TimeoutError):
InitTimeoutProxy('foo', timeout=1.)
def test_nameserverprocess_shutdown():
"""
Name server shutdown can be called directly from the name server process.
"""
nameserver = random_nameserver_process()
run_agent('a0')
run_agent('a1')
while not len(nameserver.agents()) == 2:
continue
assert 'a0' in nameserver.agents()
assert 'a1' in nameserver.agents()
nameserver.shutdown()
assert not nameserver.is_alive()
def test_reqrep(nsproxy, serializer, message, response):
"""
Simple request-reply pattern between two agents with different
serializations.
"""
def rep_handler(agent, message):
return response
a0 = run_agent('a0')
a1 = run_agent('a1')
addr = a0.bind('REP', 'reply', rep_handler, serializer=serializer)
a1.connect(addr, 'request')
assert a1.send_recv('request', message) == response
def test_pubsub(nsproxy, serializer, message):
"""
Simple publisher-subscriber pattern test with different serializations.
"""
a0 = run_agent('a0')
a1 = run_agent('a1')
a1.set_attr(received=None)
addr = a0.bind('PUB', alias='pub', serializer=serializer)
a1.connect(addr, handler=set_received)
while not a1.get_attr('received'):
a0.send('pub', message)
time.sleep(0.1)
assert a1.get_attr('received') == message
def test_return(nsproxy):
"""
REQ-REP pattern using a handler that returns a value.
"""
def rep_handler(agent, message):
return message
a0 = run_agent('a0')
a1 = run_agent('a1')
addr = a0.bind('REP', handler=rep_handler)
a1.connect(addr, alias='request')
response = a1.send_recv('request', 'Hello world')
assert response == 'Hello world'
def test_agent_proxy_remote_exceptions(nsproxy):
"""
Remote exceptions on method executions should be raised locally by the
proxy with information on what did go wrong remotely.
"""
a0 = run_agent('a0')
a1 = run_agent('a1')
with pytest.raises(TypeError) as error:
a0.addr('asdf', 'qwer', 'foo', 'bar')
assert 'positional arguments but 5 were given' in str(error.value)
with pytest.raises(RuntimeError) as error:
a1.raise_exception()
assert 'User raised an exception' in str(error.value)
def test_unsubscribe(nsproxy, socket_type):
"""
Test that unsubscribing from topics works fine.
The server will be publishing the natural numbers, in ascending order,
starting at one. Odd numbers will be sent with `odd` topic and even
numbers with `even` topic.
A subscriber will subscribe to all numbers, and then it will unsubscribe
from the odd numbers.
Two non consecutive numbers must be received consecutively at that point,
since they both will be even.
"""
def check_non_consecutive(agent):
"""
Check whether the last two received numbers are non-consecutive.
"""
return agent.received[-1] - agent.received[-2] != 1
def publish(agent):
assert agent.count % 2 == 1
agent.send('pub', agent.count, topic='odd')
agent.send('pub', agent.count + 1, topic='even')
agent.count += 2
# Set up the agents
server = run_agent('server')
client = run_agent('client', base=Client)
server.set_attr(count=1)
addr = server.bind(socket_type, alias='pub', handler=append_received)
client.connect(addr, alias='sub', handler={'odd': append_received,
'even': append_received})
# Make sure the connection is established
server.each(0.1, 'send', 'pub', 'connecting...', topic='odd', alias='tmp')
assert wait_agent_attr(client, data='connecting...')
server.stop_timer('tmp')
# Wait until client receives some numbers
client.set_attr(received=[])
server.each(0.1, publish)
assert wait_agent_attr(client, length=5)
assert not client.execute_as_method(check_non_consecutive)
# Unsubscribe from odd numbers (receiving only even numbers)
client.unsubscribe('sub', 'odd')
assert wait_agent_condition(client, check_non_consecutive)
assert client.get_attr('received')[-1] % 2 == 0
def test_nameserver_proxy_shutdown_with_many_agents():
"""
Shutdown a name server from a name server proxy when there are many agents
registered in the name server (make sure proxies do not saturate the name
server on shutdown).
The shutdown process is given a long timeout to avoid raising exceptions.
"""
import Pyro4
Pyro4.config.THREADPOOL_SIZE = 4
ns = run_nameserver()
for i in range(20):
run_agent('Agent%s' % i)
ns.shutdown(timeout=60)
def test_wait(nsproxy):
"""
Asynchronous request-reply pattern maximum wait.
When a client makes a request, it can also set a maximum wait time and
a function to be executed in case the message is not received after that
period.
"""
server = run_agent('server', base=ServerLate)
client = run_agent('client', base=Client)
logger = run_logger('logger')
client.set_logger(logger)
sync_agent_logger(client, logger)
# Connect clients
server_addr = server.addr('publish')
client.connect(server_addr, alias='sub', handler=append_received)
# Publish from server
server.each(0, 'publish')
# Wait for client to receive some data
n = 10
assert wait_agent_attr(client, length=n)
# Response received in time
fast = 0
client.send('sub', fast, handler=append_received, wait=0.5)
time.sleep(0.2)
assert server.get_attr('received') == [fast]
assert 'x' + str(fast) in client.get_attr('received')
# Response not received in time
slow = 1
client.send('sub', slow, handler=append_received, wait=0.1)
assert logger_received(logger,
log_name='log_history_warning',
message='not receive req',
timeout=0.5)
assert server.get_attr('received') == [fast, slow]
assert 'x' + str(slow) not in client.get_attr('received')
# Response not received in time with error handler
slow = 1
client.send('sub', slow, handler=append_received, wait=0.1,
on_error=on_error)
assert wait_agent_attr(client, name='error_log', length=1, timeout=0.5)
assert server.get_attr('received') == [fast, slow]
assert 'x' + str(slow) not in client.get_attr('received')
def test_agent_proxy_safe_and_unsafe_property(monkeypatch, nsproxy):
"""
Using the safe/unsafe property from a proxy should allow us to
override the environment global configuration.
"""
run_agent('foo')
# Safe environment
monkeypatch.setitem(osbrain.config, 'SAFE', True)
proxy = Proxy('foo')
assert proxy._safe
assert proxy.safe._safe
assert not proxy.unsafe._safe
# Unsafe environment
monkeypatch.setitem(osbrain.config, 'SAFE', False)
proxy = Proxy('foo')
assert not proxy._safe
assert proxy.safe._safe
assert not proxy.unsafe._safe
def test_agent_proxy_safe_and_unsafe_parameter(monkeypatch, nsproxy):
"""
Using the safe/unsafe parameter when initializing a proxy should allow
us to override the environment global configuration.
"""
run_agent('foo')
# Safe environment
monkeypatch.setitem(osbrain.config, 'SAFE', True)
proxy = Proxy('foo')
assert proxy._safe
proxy = Proxy('foo', safe=False)
assert not proxy._safe
# Unsafe environment
monkeypatch.setitem(osbrain.config, 'SAFE', False)
proxy = Proxy('foo')
assert not proxy._safe
proxy = Proxy('foo', safe=True)
assert proxy._safe
def test_close_linger(nsproxy, linger, sleep_time, should_receive):
"""
Test closing a socket with a linger value passed as parameter.
"""
class AgentTest(Agent):
def on_init(self):
self.received = []
puller = run_agent('puller', base=AgentTest)
pusher = run_agent('pusher', base=AgentTest)
address = puller.bind('PULL',
alias='pull',
handler=append_received,
transport='tcp')
pusher.connect(address, alias='push')
# Make sure connection is well established
pusher.send('push', 'ping')
assert wait_agent_attr(puller, data='ping', timeout=1)
# Shutdown the puller and restart it without binding
puller.shutdown()
assert agent_dies('puller', nsproxy)
puller = run_agent('puller', base=AgentTest)
# Push a new message, which should block during linger period
pusher.send('push', 'foo')
pusher.close(alias='push', linger=linger)
# After this timeout, depending on linger value, 'foo' will no longer be
# on queue to be sent
time.sleep(sleep_time)
# Bind to receive the message (if still in queue)
puller.bind('PULL',
alias='pull',
handler=append_received,
addr=address.address,
transport='tcp')
assert should_receive == wait_agent_attr(puller, data='foo', timeout=1)
def test_async_rep_handler_exists(nsproxy):
"""
When binding an ASYNC_REP socket without a handler, an exception must be
thrown, letting the user know that a handler must be specified.
"""
server = run_agent('server', base=Agent)
with pytest.raises(ValueError) as error:
server.bind('ASYNC_REP', alias='should_crash')
assert 'This socket requires a handler!' in str(error.value)
def test_agent_bind_transport_global(nsproxy):
"""
Test global default transport.
"""
# Default transport
agent = run_agent('a0')
address = agent.bind('PUSH')
assert address.transport == 'ipc'
# Changing default global transport
osbrain.config['TRANSPORT'] = 'tcp'
agent = run_agent('a1')
address = agent.bind('PUSH')
assert address.transport == 'tcp'
osbrain.config['TRANSPORT'] = 'ipc'
agent = run_agent('a2')
address = agent.bind('PUSH')
assert address.transport == 'ipc'
def do_connect(self, extra):
"""Connect to the robot."""
self.ns = run_nameserver()
self.proxy = run_agent("proxy", base=Proxy)
if extra == "bluetooth":
self.proxy.after(0, "setup", interface_class=BluetoothInterface)
elif extra == "serial":
self.proxy.after(0, "setup", interface_class=SerialInterface)
else:
print('Unsupported connection "{}"'.format(extra))
def create_air_agents(self):
# Room Air Agent
self.room_air = run_agent('room_air', base=AirConditioner)
self.agents.append(self.room_air)
self.room_air.set_attr(
active_area=[ROOM_X1, ROOM_Y1, ROOM_X2, ROOM_Y2],
element_tag='room')
# self.connect(self.room_air.addr('to_gui'))
self.room_air.connect(self.addr('from_gui'))
# Bedroom Air Agent
self.bedroom_air = run_agent('bedroom_air', base=AirConditioner)
self.agents.append(self.bedroom_air)
self.bedroom_air.set_attr(
active_area=[BEDROOM_X1, BEDROOM_Y1, BEDROOM_X2, BEDROOM_Y2],
element_tag='bedroom')
# self.connect(self.bedroom_air.addr('to_gui'))
self.bedroom_air.connect(self.addr('from_gui'))
def agent_start(start_date, stop_date, most_common_countries, country_code,
root_codes, correlated_countries):
# System deployment
ns = run_nameserver()
gd_agent = run_agent('GDELT',
base=AgentGDELT,
attributes=dict(
date1=start_date,
date2=stop_date,
country_code=country_code,
root_codes=root_codes,
countries_amount=most_common_countries,
correlated_countries=correlated_countries))
if gd_agent.get_len_comm_countries() == 0:
print("There are no countries with given interaction")
sys.exit()
first_layer_agents = FirstLayerAgent.create_first_layer_agents(gd_agent)
second_layer_agents = SecondLayerAgents.create_second_layer_agents(
root_codes, first_layer_agents)
# System configuration
FirstLayerAgent.connect_agents(first_layer_agents, gd_agent)
SecondLayerAgents.connect_agents(second_layer_agents, first_layer_agents)
# Send messages
gd_agent.publish_gdelt()
FirstLayerAgent.publish_events(first_layer_agents, country_code)
# Plot informations
all_combinations_count = sum(list(range(1, len(correlated_countries))))
stats_agents = [
a for a in second_layer_agents
if a.get_attr('topic')[0] == AGENT_DATA['stats_agents_id']
]
trends_agents = [
a for a in stats_agents if 'trend_line' in a.get_attr('topic')
]
diplomacy_agents = [
a for a in stats_agents if 'diplomacy' in a.get_attr('topic')
]
cameo_agents = [
a for a in second_layer_agents
if a.get_attr('topic')[0] != AGENT_DATA['stats_agents_id']
]
SecondLayerAgents.plot_countries_interaction(cameo_agents, root_codes,
country_code, start_date,
stop_date)
SecondLayerAgents.calculate_correlations_and_find_allies(
diplomacy_agents, all_combinations_count, correlated_countries)
SecondLayerAgents.plot_trends(trends_agents, correlated_countries)
# Server shutdown
ns.shutdown()
def test_agent_close_ipc_socket_nameserver_shutdown():
"""
Check that the socket is closed and the socket file removed after the name
server is shut down.
"""
ns = run_nameserver()
agent = run_agent('agent')
addr = agent.bind('PUSH', 'main')
ns.shutdown()
assert wait_condition(addr.address.exists, negate=True)
def test_agent_close_ipc_socket_agent_kill(nsproxy):
"""
Check that the socket is closed and the socket file removed after the agent
is killed.
"""
agent = run_agent('name')
address = agent.bind('PUSH')
agent.oneway.kill()
assert agent_dies('name', nsproxy)
assert wait_condition(address.address.exists, negate=True)
def test_timer_each_stop_alias(nsproxy):
"""
Test a timer executed periodically and stopped by an alias.
"""
def tick(agent):
agent.send('push', agent.count)
agent.count += 1
sender = run_agent('sender')
receiver = run_agent('receiver')
addr = sender.bind('PUSH', alias='push')
receiver.connect(addr, handler=set_received)
sender.set_attr(count=0)
sender.each(0.1, tick, alias='aliased_timer')
time.sleep(1)
assert abs(receiver.get_attr('received') - 10) <= 1
sender.stop_timer('aliased_timer')
time.sleep(1)
assert abs(receiver.get_attr('received') - 10) <= 1
assert 'aliased_timer' not in sender.list_timers()
def __init__(self, alias):
self.agent = run_agent(alias)
self.name = alias
self.weight = random.randint(0, 20)
self.type = 'sensor'
self.posX = random.randint(1, 30)
self.posY = random.randint(1, 30)
self.agentList.append({
'name': alias,
'posX': self.posX,
'posY': self.posY
})
def test_agent_loopback(nsproxy):
"""
An agent should always have a _loopback_safe inproc socket.
"""
a0 = run_agent('a0')
assert a0.addr('_loopback_safe') == AgentAddress(
transport='inproc',
address='_loopback_safe',
kind='REP',
role='server',
serializer='pickle',
)
def test_async_rep_send_handler_types(nsproxy, handler, check_function):
"""
We should be able to make requests even if we do not specify a handler
on the `connect` call, as long as we specify it on the `send` call.
"""
server = run_agent('server', base=ServerAsyncRep)
client = run_agent('client', base=ClientWithHandler)
addr = server.addr('publish')
# Connect without a handler
client.connect(addr, alias='sub')
client.send('sub', 'request!', handler=handler)
assert wait_agent_attr(client, length=1)
if check_function:
# Check that the function was not stored as a method for the object
with pytest.raises(AttributeError) as error:
assert client.get_attr('append_received')
assert 'object has no attribute' in str(error.value)
def test_simple_pub_single_handler(nsproxy, server):
"""
SYNC_PUB should work just like a normal PUB. This test checks normal
behavior when using a single handler (i.e.: no filtering).
When clients connect to a SYNC_PUB server, as long as they do not make
requests, this communication pattern should behave exactly like a normal
PUB-SUB pattern.
"""
server = run_agent('server', base=server)
alltopics = run_agent('alltopics', base=Client)
# Connect clients
addr = server.addr('publish')
addr_alltopics = alltopics.connect(addr, handler=receive)
assert addr_alltopics == addr.twin()
# Publish from server
server.each(0, 'publish_str')
# Wait for clients to receive some data
N = 10
assert wait_agent_attr(alltopics, length=N)
# alltopics
received = [
int(x) for x in alltopics.get_attr('received') if x != 'bytes...'
]
assert len(received) >= N
for i in range(2, len(received)):
if received[i] > 0:
if received[i - 1] == 'bytes...':
assert received[i - 2] == 1 - received[i]
else:
assert received[i - 1] == 1 - received[i]
else:
if received[i - 1] == 'bytes...':
assert received[i - 2] == -received[i]
else:
assert received[i - 1] == -received[i]