Python SocketManager.wait_until_ready方法代码示例

# 需要导入模块: from agentzero.core import SocketManager [as 别名]
# 或者: from agentzero.core.SocketManager import wait_until_ready [as 别名]
def test_socket_manager_can_poll_asynchronously():
    ("SocketManager should leverage a non-blocking socket "
     "collection can be used seamlessly in a blocking fashion [TCP SOCKET]")

    # Given a socket manager for a server
    server = SocketManager(zmq, context)
    # And a reply socket listening on a tcp port
    server.ensure_and_bind('reply-server', zmq.REP, 'tcp://0.0.0.0:3458', zmq.POLLIN | zmq.POLLOUT)

    # And a socket manager for a client
    client = SocketManager(zmq, context)

    # And a request client connected to the server
    client.ensure_and_connect('request-client', zmq.REQ, 'tcp://0.0.0.0:3458', zmq.POLLIN | zmq.POLLOUT)

    # And send a request from the client
    requester = client.wait_until_ready('request-client', zmq.POLLOUT, timeout=2)
    requester.send_json({'client': 42})

    # Then I should receive a request from the client
    replier = server.wait_until_ready('reply-server', zmq.POLLIN, timeout=2)
    replier.should_not.be.none
    request = replier.recv_json()

    # And the request should be the one that the client just sent
    request.should.equal({'client': 42})

# 需要导入模块: from agentzero.core import SocketManager [as 别名]
# 或者: from agentzero.core.SocketManager import wait_until_ready [as 别名]
def test_socket_manager_wait_until_ready(ready, engage, gevent, time):
    ("SocketManager().wait_until_ready() whould engage and poll "
     "continously until the socket becomes available")

    # Background: time.time() is mocked tick for 3 iterations
    time.time.side_effect = range(3)

    # Background: SocketManager().ready() is mocked to return a socket
    # only after the second iteration
    socket = Mock(name='socket-ready-to-go')
    ready.side_effect = [None, socket]

    # Given a zmq mock
    zmq = Mock()

    # And a context
    context = Mock()

    # And a socket manager
    manager = SocketManager(zmq, context)

    # When I call wait_until_ready
    result = manager.wait_until_ready(
        "foobar",
        "some-mechanism",
        timeout=2,
        polling_timeout=42
    )

    # Then it should have returned the socket
    result.should.equal(socket)

    # And it should have engaged twice
    engage.assert_has_calls([
        call(42),
        call(42),
    ])

    # And ready should also have been called twice
    ready.assert_has_calls([
        call('foobar', 'some-mechanism'),
        call('foobar', 'some-mechanism'),
    ])

    # And gevent.sleep should have been called twice
    gevent.sleep.assert_has_calls([
        call(),
        call(),
    ])