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_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_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_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_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_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_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)