def test_stop(self, conn):
ag, a, id1, id2 = dA(conn), A(), uuid(), uuid()
ag.state.spawn(qualname(a), id1)
ag.state.spawn(qualname(a), id2)
self.assertEquals(len(ag.state.registry), 2)
actor1, actor2 = ag.state.registry[id1], ag.state.registry[id2]
ag.stop()
self.assertEquals(len(ag.state.registry), 2)
self.assertEquals(actor1.consumer.channel.queues, {})
self.assertEquals(actor2.consumer.channel.queues, {})
def test_stop(self, conn):
ag, a, id1, id2 = dA(conn), A(), uuid(), uuid()
ag.state.spawn(qualname(a), id1)
ag.state.spawn(qualname(a), id2)
self.assertEquals(len(ag.state.registry), 2)
actor1, actor2 = ag.state.registry[id1], ag.state.registry[id2]
ag.stop()
self.assertEquals(len(ag.state.registry), 2)
self.assertEquals(actor1.consumer.channel.queues, {})
self.assertEquals(actor2.consumer.channel.queues, {})
def test_state_spawn_when_id_in_registry(self, conn, warn):
ag, a1 = dA(conn), A(conn)
ag.state.registry[a1.id] = a1
ag.state.spawn(qualname(a1), a1.id)
warn.assert_called_once_with(ANY, a1.id)
def test_state_spawn_when_id_in_registry(self, conn, warn):
ag, a1 = dA(conn), A(conn)
ag.state.registry[a1.id] = a1
ag.state.spawn(qualname(a1), a1.id)
warn.assert_called_once_with(ANY, a1.id)
def test_spawn(self, conn, actor_static_id, ticket_static_id, proxy):
# Ensure the ActorProxy is returned
# Ensure cast is invoked with the correct arguments
ag, a = dA(conn), A()
ag.cast = Mock()
proxy = ag.spawn(A)
ag.cast.assert_called_once_with('spawn', {
'cls': qualname(a),
'id': actor_static_id.return_value,
'kwargs': {}
},
reply_to=ticket_static_id.return_value,
declare=ANY,
type=ACTOR_TYPE.RR,
nowait=False)
# Check ActorProxy initialisation
self.assertIsInstance(proxy, ActorProxy)
self.assertEqual(proxy.id, actor_static_id.return_value)
self.assertIsInstance(proxy._actor, A)
self.assertEqual(proxy._actor.name, A().__class__.__name__)
self.assertEqual(proxy._actor.connection, conn)
self.assertEqual(proxy._actor.agent, ag)
self.assertEqual(proxy.async_start_result.ticket,
ticket_static_id.return_value)
# Agent state is not affected by the remote spawn call
self.assertDictEqual(ag.state.registry, {})
def test_spawn(self, conn, actor_static_id, ticket_static_id, proxy):
# Ensure the ActorProxy is returned
# Ensure cast is invoked with the correct arguments
ag, a = dA(conn), A()
ag.cast = Mock()
proxy = ag.spawn(A)
ag.cast.assert_called_once_with(
'spawn',
{'cls': qualname(a), 'id': actor_static_id.return_value,
'kwargs': {}},
reply_to=ticket_static_id.return_value, declare=ANY,
type=ACTOR_TYPE.RR, nowait=False)
# Check ActorProxy initialisation
self.assertIsInstance(proxy, ActorProxy)
self.assertEqual(proxy.id, actor_static_id.return_value)
self.assertIsInstance(proxy._actor, A)
self.assertEqual(proxy._actor.name, A().__class__.__name__)
self.assertEqual(proxy._actor.connection, conn)
self.assertEqual(proxy._actor.agent, ag)
self.assertEqual(proxy.async_start_result.ticket,
ticket_static_id.return_value)
# Agent state is not affected by the remote spawn call
self.assertDictEqual(ag.state.registry, {})
def test_reset(self, conn, consumer):
ag, a1 = dA(conn), A()
ag.state.spawn(qualname(a1), a1.id)
a1 = ag.state.registry[a1.id]
ag.state.reset()
self.assertIsNotNone(a1.consumer)
self.assertEqual(len(ag.state.registry), 1)
self.assertEqual(a1.consumer.cancel.call_count, 1)
def test_state_stop_actor_by_id(self, conn, consumer):
ag, a, id = dA(conn), A(), uuid()
ag.state.spawn(qualname(a), id)
self.assertEquals(len(ag.state.registry), 1)
actor = ag.state.registry[id]
ag.state.kill(id)
self.assertEquals(ag.state.registry, {})
actor.consumer.cancel.assert_called_once_with()
def test_state_stop_actor_by_id(self, conn, consumer):
ag, a, id = dA(conn), A(), uuid()
ag.state.spawn(qualname(a), id)
self.assertEquals(len(ag.state.registry), 1)
actor = ag.state.registry[id]
ag.state.kill(id)
self.assertEquals(ag.state.registry, {})
actor.consumer.cancel.assert_called_once_with()
def test_reset(self, conn, consumer):
ag, a1 = dA(conn), A()
ag.state.spawn(qualname(a1), a1.id)
a1 = ag.state.registry[a1.id]
ag.state.reset()
self.assertIsNotNone(a1.consumer)
self.assertEqual(len(ag.state.registry), 1)
self.assertEqual(a1.consumer.cancel.call_count, 1)
def test_arbitrary_actor_method(self, meth):
a1 = ActorProxy(qualname(As), uuid())
a1.meth()
meth.assert_called_once_with()
meth.reset_mock()
args = ['bar']
a1.meth(*args)
meth.assert_called_once_with(*args)
def test_state_select_returns_from_registry(self, conn):
class B(Actor):
pass
ag = dAgent(conn)
id1, id2 = uuid(), uuid()
with self.assertRaises(Actor.Next):
ag.state.select(qualname(A))
ag.state.registry[id1] = A()
key = ag.state.select(qualname(A))
self.assertEqual(key, id1)
ag.state.registry[id2] = B(conn)
keyA = ag.state.select(qualname(A))
keyB = ag.state.select(qualname(B))
self.assertEqual(keyA, id1)
self.assertEqual(keyB, id2)
def test_state_spawn_when_id_not_in_registry(self, conn, consumer):
ag, a, id = dA(conn), A(), uuid()
self.assertEquals(ag.state.registry, {})
ag.state.spawn(qualname(a), id)
self.assertEquals(len(ag.state.registry), 1)
actor = ag.state.registry[id]
self.assertIs(type(actor), A)
self.assertIsNotNone(actor.consumer)
actor.consumer.consume.assert_called_once_with()
def test_state_select_returns_from_registry(self, conn):
class B(Actor):
pass
ag = dAgent(conn)
id1, id2 = uuid(), uuid()
with self.assertRaises(Actor.Next):
ag.state.select(qualname(A))
ag.state.registry[id1] = A()
key = ag.state.select(qualname(A))
self.assertEqual(key, id1)
ag.state.registry[id2] = B(conn)
keyA = ag.state.select(qualname(A))
keyB = ag.state.select(qualname(B))
self.assertEqual(keyA, id1)
self.assertEqual(keyB, id2)
def test_arbitrary_actor_method(self, meth):
a1 = ActorProxy(qualname(As), uuid())
a1.meth()
meth.assert_called_once_with()
meth.reset_mock()
args = ['bar']
a1.meth(*args)
meth.assert_called_once_with(*args)
def test_state_spawn_when_id_not_in_registry(self, conn, consumer):
ag, a, id = dA(conn), A(), uuid()
self.assertEquals(ag.state.registry, {})
ag.state.spawn(qualname(a), id)
self.assertEquals(len(ag.state.registry), 1)
actor = ag.state.registry[id]
self.assertIs(type(actor), A)
self.assertIsNotNone(actor.consumer)
actor.consumer.consume.assert_called_once_with()
def test_init(self, conn):
"""test that __init__ sets fields"""
id = uuid()
ag, res = Mock(), Mock()
# we need to have wait for result,
a1 = ActorProxy(qualname(A), id, connection=conn, agent=ag)
self.assertEqual(a1.id, id)
self.assertIsNone(a1.async_start_result)
self.assertIsInstance(a1._actor, A)
self.assertEqual(a1._actor.name, A().__class__.__name__)
self.assertEqual(a1._actor.agent, ag)
self.assertEqual(a1._actor.id, a1.id)
self.assertEqual(a1._actor.connection, conn)
a1 = ActorProxy(qualname(A), id, res, connection=conn, agent=ag)
self.assertEqual(a1.id, id)
self.assertEqual(a1.async_start_result, res)
self.assertEqual(a1._actor.id, a1.id)
self.assertIsInstance(a1._actor, A)
self.assertEqual(a1._actor.name, A().__class__.__name__)
self.assertEqual(a1._actor.agent, ag)
self.assertEqual(a1._actor.connection, conn)
def test_state_spawn_when_error_occurs(self, conn, error):
ag, a1 = dA(conn), A(conn)
ag.state.registry[a1.id] = a1
ag.state._start_actor_consumer = Mock(
side_effect=Exception('FooError'))
ag.state.spawn(qualname(a1), a1.id)
error.called_once_with('Cannot start actor: %r', Exception('FooError'),
ANY)
ag.state._start_actor_consumer.reset_mock()
ag.state._start_actor_consumer = Mock()
error.reset_mock()
ag.state.spawn('Ala Bala', a1.id)
error.called_once_with('Cannot start actor: %r', 'ihu', ANY)
def test_state_spawn_when_error_occurs(self, conn, error):
ag, a1 = dA(conn), A(conn)
ag.state.registry[a1.id] = a1
ag.state._start_actor_consumer = Mock(
side_effect=Exception('FooError'))
ag.state.spawn(qualname(a1), a1.id)
error.called_once_with('Cannot start actor: %r',
Exception('FooError'), ANY)
ag.state._start_actor_consumer.reset_mock()
ag.state._start_actor_consumer = Mock()
error.reset_mock()
ag.state.spawn('Ala Bala', a1.id)
error.called_once_with('Cannot start actor: %r', 'ihu', ANY)
def test_init(self, conn):
"""test that __init__ sets fields"""
id = uuid()
ag, res = Mock(), Mock()
# we need to have wait for result,
a1 = ActorProxy(qualname(A), id, connection=conn, agent=ag)
self.assertEqual(a1.id, id)
self.assertIsNone(a1.async_start_result)
self.assertIsInstance(a1._actor, A)
self.assertEqual(a1._actor.name, A().__class__.__name__)
self.assertEqual(a1._actor.agent, ag)
self.assertEqual(a1._actor.id, a1.id)
self.assertEqual(a1._actor.connection, conn)
a1 = ActorProxy(qualname(A), id, res, connection=conn, agent=ag)
self.assertEqual(a1.id, id)
self.assertEqual(a1.async_start_result, res)
self.assertEqual(a1._actor.id, a1.id)
self.assertIsInstance(a1._actor, A)
self.assertEqual(a1._actor.name, A().__class__.__name__)
self.assertEqual(a1._actor.agent, ag)
self.assertEqual(a1._actor.connection, conn)
def test_select_returns_scatter_results(self, conn):
id1, id2 = uuid(), uuid()
def scatter_result():
yield id1
yield id2
ag = dAgent(conn)
ag.scatter = Mock(return_value=scatter_result())
proxy = ag.select(A)
ag.scatter.assert_called_once_with('select', {'cls': qualname(A)},
limit=1)
# Check ActorProxy initialisation
self.assertIsInstance(proxy, ActorProxy)
self.assertEqual(proxy.id, id1)
self.assertIsInstance(proxy._actor, A)
self.assertEqual(proxy._actor.name, A().__class__.__name__)
self.assertEqual(proxy._actor.connection, conn)
self.assertEqual(proxy._actor.agent, ag)
self.assertIsNone(proxy.async_start_result)
def test_select_returns_scatter_results(self, conn):
id1, id2 = uuid(), uuid()
def scatter_result():
yield id1
yield id2
ag = dAgent(conn)
ag.scatter = Mock(return_value=scatter_result())
proxy = ag.select(A)
ag.scatter.assert_called_once_with(
'select', {'cls': qualname(A)}, limit=1)
# Check ActorProxy initialisation
self.assertIsInstance(proxy, ActorProxy)
self.assertEqual(proxy.id, id1)
self.assertIsInstance(proxy._actor, A)
self.assertEqual(proxy._actor.name, A().__class__.__name__)
self.assertEqual(proxy._actor.connection, conn)
self.assertEqual(proxy._actor.agent, ag)
self.assertIsNone(proxy.async_start_result)
def test_scatter(self, scatter):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(scatter, a1.scatter)
def test_throw_dot(self, throw):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called_with_par_foo(throw, a1.throw)
def test_throw(self, throw):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(throw, a1.throw)
def test_send_dot(self, send):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called_with_par_foo(send, a1.send)
def test_send(self, send):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(send, a1.send)
def test_send(self, send):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(send, a1.send)
def test_non_existing_actor_method(self):
a1 = ActorProxy(qualname(As), uuid())
with self.assertRaises(AttributeError):
a1.bar()
def test_non_existing_actor_method(self):
a1 = ActorProxy(qualname(As), uuid())
with self.assertRaises(AttributeError):
a1.bar()
def test_scatter_dot(self, scatter):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called_with_par_foo(scatter, a1.scatter)
def test_scatter(self, scatter):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(scatter, a1.scatter)
def test_throw_dot(self, throw):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called_with_par_foo(throw, a1.throw)
def test_throw(self, throw):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(throw, a1.throw)
def test_send_dot(self, send):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called_with_par_foo(send, a1.send)
def test_scatter_dot(self, scatter):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called_with_par_foo(scatter, a1.scatter)
def test_call_dot(self, call):
a1 = ActorProxy(qualname(As), uuid)
self.assert_actor_method_called_with_par_foo(call, a1.call)
def test_call(self, call):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(call, a1.call)
def test_call(self, call):
a1 = ActorProxy(qualname(As), uuid())
self.assert_actor_method_called(call, a1.call)
def test_call_dot(self, call):
a1 = ActorProxy(qualname(As), uuid)
self.assert_actor_method_called_with_par_foo(call, a1.call)
