def test_specified_host(self, patched_socket):
host = '10.0.0.1'
free_port = 9999
mock_sock = patched_socket.socket()
mock_sock.getsockname.return_value = [host, free_port]
assert find_free_port(host) == free_port
assert mock_sock.bind.call_args_list == [call((host, 0))]
assert mock_sock.close.called
def web_config(empty_config):
from nameko.constants import WEB_SERVER_CONFIG_KEY
from nameko.testing.utils import find_free_port
port = find_free_port()
cfg = empty_config
cfg[WEB_SERVER_CONFIG_KEY] = str(port)
return cfg
def web_config(empty_config):
from nameko.constants import WEB_SERVER_CONFIG_KEY
from nameko.testing.utils import find_free_port
port = find_free_port()
cfg = empty_config
cfg[WEB_SERVER_CONFIG_KEY] = "127.0.0.1:{}".format(port)
return cfg
def grpc_port():
return find_free_port()
def toxiproxy(toxiproxy_server, rabbit_config):
""" Insert a toxiproxy in front of RabbitMQ
https://github.com/douglas/toxiproxy-python is not released yet, so
we use requests to control the server.
"""
# extract rabbit connection details
amqp_uri = rabbit_config['AMQP_URI']
uri = urlparse(amqp_uri)
rabbit_port = uri.port
proxy_port = find_free_port()
# create proxy
proxy_name = "nameko_test_rabbitmq_{}".format(uuid.uuid4().hex)
listen = "{}:{}".format(uri.hostname, proxy_port)
upstream = "{}:{}".format(uri.hostname, rabbit_port)
requests.post('http://{}/proxies'.format(toxiproxy_server),
data=json.dumps({
'name': proxy_name,
'listen': listen,
'upstream': upstream
}))
# create proxied uri for publisher
proxy_uri = "{}://{}:{}@{}{}".format(uri.scheme, uri.username,
uri.password, listen, uri.path)
toxic_name = '{}_timeout'.format(proxy_name)
class Controller(object):
def __init__(self, proxy_uri):
self.uri = proxy_uri
def enable(self):
resource = 'http://{}/proxies/{}'.format(toxiproxy_server,
proxy_name)
data = {'enabled': True}
requests.post(resource, json.dumps(data))
def disable(self):
resource = 'http://{}/proxies/{}'.format(toxiproxy_server,
proxy_name)
data = {'enabled': False}
requests.post(resource, json.dumps(data))
def set_timeout(self, timeout=500, stream="upstream"):
resource = 'http://{}/proxies/{}/toxics'.format(
toxiproxy_server, proxy_name)
data = {
'name': toxic_name,
'type': 'timeout',
'stream': stream,
'attributes': {
'timeout': timeout
}
}
requests.post(resource, json.dumps(data))
def reset_timeout(self):
resource = 'http://{}/proxies/{}/toxics/{}'.format(
toxiproxy_server, proxy_name, toxic_name)
requests.delete(resource)
def reset(self):
# ensure the proxy passes traffic healthily again, so test cleanup
# doesn't get stuck trying to reconnect
self.enable()
self.reset_timeout()
controller = Controller(proxy_uri)
yield controller
controller.reset()
def toxiproxy(toxiproxy_server, rabbit_config):
""" Insert a toxiproxy in front of RabbitMQ
https://github.com/douglas/toxiproxy-python is not released yet, so
we use requests to control the server.
"""
# extract rabbit connection details
amqp_uri = rabbit_config['AMQP_URI']
uri = urlparse(amqp_uri)
rabbit_port = uri.port
proxy_port = find_free_port()
# create proxy
proxy_name = "nameko_test_rabbitmq_{}".format(uuid.uuid4().hex)
listen = "{}:{}".format(uri.hostname, proxy_port)
upstream = "{}:{}".format(uri.hostname, rabbit_port)
requests.post(
'http://{}/proxies'.format(toxiproxy_server),
data=json.dumps({
'name': proxy_name,
'listen': listen,
'upstream': upstream
})
)
# create proxied uri for publisher
proxy_uri = "{}://{}:{}@{}{}".format(
uri.scheme, uri.username, uri.password, listen, uri.path
)
toxic_name = '{}_timeout'.format(proxy_name)
class Controller(object):
def __init__(self, proxy_uri):
self.uri = proxy_uri
def enable(self):
resource = 'http://{}/proxies/{}'.format(
toxiproxy_server, proxy_name
)
data = {
'enabled': True
}
requests.post(resource, json.dumps(data))
def disable(self):
resource = 'http://{}/proxies/{}'.format(
toxiproxy_server, proxy_name
)
data = {
'enabled': False
}
requests.post(resource, json.dumps(data))
def set_timeout(self, timeout=500, stream="upstream"):
resource = 'http://{}/proxies/{}/toxics'.format(
toxiproxy_server, proxy_name
)
data = {
'name': toxic_name,
'type': 'timeout',
'stream': stream,
'attributes': {
'timeout': timeout
}
}
requests.post(resource, json.dumps(data))
def reset_timeout(self):
resource = 'http://{}/proxies/{}/toxics/{}'.format(
toxiproxy_server, proxy_name, toxic_name
)
requests.delete(resource)
@contextmanager
def disabled(self):
self.disable()
yield
self.enable()
@contextmanager
def timeout(self, timeout=500, stream="upstream"):
self.set_timeout(timeout=timeout, stream=stream)
yield
self.reset_timeout()
controller = Controller(proxy_uri)
yield controller
# delete proxy
# allow some grace period to ensure we don't remove the proxy before
# other fixtures have torn down
resource = 'http://{}/proxies/{}'.format(toxiproxy_server, proxy_name)
eventlet.spawn_after(10, requests.delete, resource)
def toxiproxy(toxiproxy_server, rabbit_config):
""" Insert a toxiproxy in front of RabbitMQ
https://github.com/douglas/toxiproxy-python is not released yet, so
we use requests to control the server.
"""
# extract rabbit connection details
amqp_uri = rabbit_config['AMQP_URI']
uri = urlparse(amqp_uri)
rabbit_port = uri.port
proxy_port = find_free_port()
# create proxy
proxy_name = "nameko_test_rabbitmq_{}".format(uuid.uuid4().hex)
listen = "{}:{}".format(uri.hostname, proxy_port)
upstream = "{}:{}".format(uri.hostname, rabbit_port)
requests.post('http://{}/proxies'.format(toxiproxy_server),
data=json.dumps({
'name': proxy_name,
'listen': listen,
'upstream': upstream
}))
# create proxied uri for publisher
proxy_uri = "{}://{}:{}@{}{}".format(uri.scheme, uri.username,
uri.password, listen, uri.path)
toxic_name = '{}_timeout'.format(proxy_name)
class Controller(object):
def __init__(self, proxy_uri):
self.uri = proxy_uri
def enable(self):
resource = 'http://{}/proxies/{}'.format(toxiproxy_server,
proxy_name)
data = {'enabled': True}
requests.post(resource, json.dumps(data))
def disable(self):
resource = 'http://{}/proxies/{}'.format(toxiproxy_server,
proxy_name)
data = {'enabled': False}
requests.post(resource, json.dumps(data))
def set_timeout(self, timeout=500, stream="upstream"):
resource = 'http://{}/proxies/{}/toxics'.format(
toxiproxy_server, proxy_name)
data = {
'name': toxic_name,
'type': 'timeout',
'stream': stream,
'attributes': {
'timeout': timeout
}
}
requests.post(resource, json.dumps(data))
def reset_timeout(self):
resource = 'http://{}/proxies/{}/toxics/{}'.format(
toxiproxy_server, proxy_name, toxic_name)
requests.delete(resource)
@contextmanager
def disabled(self):
self.disable()
yield
self.enable()
@contextmanager
def timeout(self, timeout=500, stream="upstream"):
self.set_timeout(timeout=timeout, stream=stream)
yield
self.reset_timeout()
controller = Controller(proxy_uri)
yield controller
# delete proxy
# allow some grace period to ensure we don't remove the proxy before
# other fixtures have torn down
resource = 'http://{}/proxies/{}'.format(toxiproxy_server, proxy_name)
eventlet.spawn_after(10, requests.delete, resource)
def salesforce_server_port():
return find_free_port()
def cometd_server_port():
return find_free_port()
