def test_connection_is_aborted_when_not_authorised(router):
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'not-an-expected-user',
}
client = Client(
url=router.url, roles=roles, name="unauthenticated-client-one")
with pytest.raises(WampyError) as exc_info:
client.start()
client.stop()
exception = exc_info.value
message = str(exception)
assert (
"no principal with authid \"not-an-expected-user\" exists"
in message
)
assert "wamp.error.not_authorized" in message
def test_incorrect_secret(router):
os.environ['WAMPYSECRET'] = "incorrect-password"
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'peter',
}
client = Client(
url=router.url,
roles=roles,
name="bad-client"
)
with pytest.raises(WampyError) as exc_info:
client.start()
exception = exc_info.value
message = str(exception)
assert (
"WAMP-CRA signature is invalid"
in message
)
assert "wamp.error.not_authorized" in message
def setup(self):
self.config_path = self.container.config[
WAMP_CONFIG_KEY]['config_path']
self.router = Router(config_path=self.config_path)
self.client = Client(
router=self.router, name="nameko-wamp client proxy"
)
def test_incorrect_ticket(router):
os.environ['WAMPYSECRET'] = "incorrect-ticket"
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['ticket'],
'authid': 'martin',
}
client = Client(
url=router.url,
roles=roles,
name="bad-client"
)
with pytest.raises(WampyError) as exc_info:
client.start()
exception = exc_info.value
message = str(exception)
assert (
"ticket in static WAMP-Ticket authentication is invalid"
in message
)
assert "wamp.error.not_authorized" in message
def test_incorrect_ticket(router):
os.environ['WAMPYSECRET'] = "incorrect-ticket"
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['ticket'],
'authid': 'martin',
}
client = Client(url=router.url, roles=roles, name="bad-client")
with pytest.raises(WampyError) as exc_info:
client.start()
exception = exc_info.value
message = str(exception)
assert ("ticket in static WAMP-Ticket authentication is invalid"
in message)
assert "wamp.error.not_authorized" in message
def test_kwargs_are_received(router):
class SubscribingClient(Client):
received_kwargs = None
@subscribe(topic="foo")
def foo_topic_handler(self, **kwargs):
SubscribingClient.received_kwargs = kwargs
reader = SubscribingClient(url=router.url)
assert SubscribingClient.received_kwargs is None
with reader:
assert SubscribingClient.received_kwargs is None
publisher = Client(url=router.url)
assert SubscribingClient.received_kwargs is None
with publisher:
publisher.publish(topic="foo", message="foobar", spam="eggs")
def check_kwargs():
assert SubscribingClient.received_kwargs == {
'message': 'foobar',
'spam': 'eggs',
'meta': {
'topic': 'foo',
'subscription_id': ANY,
},
}
assert_stops_raising(check_kwargs)
def test_connection_is_ticket_challenged(router):
os.environ['WAMPYSECRET'] = "wEx9TPFtHdRr2Zg7rtRE"
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['ticket'],
'authid': 'martin',
}
client = Client(
url=router.url,
roles=roles,
message_handler_cls=CollectingMessageHandler,
name="unauthenticated-client"
)
client.start()
messages = wait_for_messages(client, 2)
# expect a Challenge and Welcome message
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
client.stop()
# now also expect a Goodbye message
assert len(messages) == 3
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
assert messages[2][0] == Goodbye.WAMP_CODE
def test_kwargs_are_received(router):
class SubscribingClient(Client):
received_kwargs = None
@subscribe(topic="foo")
def foo_topic_handler(self, **kwargs):
SubscribingClient.received_kwargs = kwargs
reader = SubscribingClient(url=router.url)
assert SubscribingClient.received_kwargs is None
with reader:
assert SubscribingClient.received_kwargs is None
publisher = Client(url=router.url)
assert SubscribingClient.received_kwargs is None
with publisher:
publisher.publish(
topic="foo", message="foobar", spam="eggs")
def check_kwargs():
assert SubscribingClient.received_kwargs == {
'message': 'foobar',
'spam': 'eggs',
'meta': {
'topic': 'foo',
'subscription_id': ANY,
},
}
assert_stops_raising(check_kwargs)
def test_call_with_no_args_or_kwargs(self, date_service, router):
client = Client(router=router)
with client:
response = client.call("get_todays_date")
today = date.today()
assert response == today.isoformat()
def test_call_with_no_args_or_kwargs(self, date_service, router):
client = Client(url=router.url)
with client:
response = client.call("get_todays_date")
today = date.today()
assert response == today.isoformat()
def test_cannot_publish_nothing_to_topic(foo_subscriber, router):
assert foo_subscriber.call_count == 0
client = Client(url=router.url)
with client:
with pytest.raises(WampyError):
client.publish(topic="foo")
assert foo_subscriber.call_count == 0
def test_cannot_publish_nothing_to_topic(foo_subscriber, router):
assert foo_subscriber.call_count == 0
client = Client(url=router.url)
with client:
with pytest.raises(WampyError):
client.publish(topic="foo")
assert foo_subscriber.call_count == 0
def __init__(self, component):
self.host = os.environ.get("TEP_WAMP_HOST", "127.0.0.1")
self.port = int(os.environ.get("TEP_WAMP_PORT", 8080))
Client.__init__(self, realm="tuxeatpi", url="ws://{}:{}".format(self.host, self.port))
self.component = component
self.logger = logging.getLogger(name="tep").getChild(component.name).getChild('wampclient')
self._must_run = True
self.topics = {}
self.rpc_funcs = {}
self._get_topics()
def setup_class(self):
intents_folder = "tests/daemon_test/intents"
dialogs_folder = "tests/daemon_test/dialogs"
workdir = "tests/daemon_test/workdir"
self.fake_daemon = FakeDaemon("fake_daemon", workdir, intents_folder,
dialogs_folder)
self.fake_daemon.settings.delete("/config/global")
self.fake_daemon.settings.delete()
self.wamp_client = Client(realm="tuxeatpi")
self.wamp_client.start()
def test_nameko_service_can_subscribe_to_wamp_topic(
runner_factory, router, config_path
):
wamp_client = Client(router=router)
config = {
WAMP_CONFIG_KEY: {
'config_path': config_path,
}
}
runner = runner_factory(config, WampSubscriber)
runner.start()
container = get_container(runner, WampSubscriber)
with wamp_client as client:
wait_for_session(client)
wait_for_subscriptions(container, number_of_subscriptions=2)
client.publish(topic="foo", message="hello foo")
client.publish(topic="bar", message="hello bar")
def waiting_for_the_message():
assert len(WampSubscriber.messages) == 2
assert sorted(WampSubscriber.messages) == sorted([
((u'hello foo',), {}),
((u'hello bar',), {})
])
assert_stops_raising(waiting_for_the_message)
WampSubscriber.messages = []
def test_ipv4_secure_websocket_connection_by_router_url(
self, config_path, router):
assert router.url == "wss://localhost:9443"
try:
ssl.PROTOCOL_TLSv1_2
except AttributeError:
pytest.skip('Python Environment does not support TLS')
with DateService(
url="wss://localhost:9443",
cert_path="./wampy/testing/keys/server_cert.pem",
) as service:
wait_for_registrations(service, 1)
client = Client(
url="wss://localhost:9443",
cert_path="./wampy/testing/keys/server_cert.pem",
)
with client:
wait_for_session(client)
result = client.rpc.get_todays_date()
today = date.today()
assert result == today.isoformat()
class WampClientProxy(Extension):
def setup(self):
self.config_path = self.container.config[
WAMP_CONFIG_KEY]['config_path']
self.router = Router(config_path=self.config_path)
self.client = Client(
router=self.router, name="nameko-wamp client proxy"
)
def start(self):
self.client.start()
def stop(self):
try:
self.client.stop()
except AttributeError:
pass
def test_pinging(router):
with patch('wampy.transports.websocket.connection.heartbeat', 1):
with patch(
'wampy.transports.websocket.connection.heartbeat_timeout', 2
):
client = Client(router.url)
client.start()
wait_for_session(client)
assert client.is_pinging
ws = client.session.connection
assert ws.missed_pongs == 0
async_adapter.sleep(10)
assert ws.missed_pongs == 0
client.stop()
def test_connection_is_ticket_challenged(router):
os.environ['WAMPYSECRET'] = "wEx9TPFtHdRr2Zg7rtRE"
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['ticket'],
'authid': 'martin',
}
client = Client(url=router.url,
roles=roles,
message_handler_cls=CollectingMessageHandler,
name="unauthenticated-client")
client.start()
messages = wait_for_messages(client, 2)
# expect a Challenge and Welcome message
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
client.stop()
# now also expect a Goodbye message
assert len(messages) == 3
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
assert messages[2][0] == Goodbye.WAMP_CODE
def test_connection_is_aborted_when_not_authorised(router):
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'not-an-expected-user',
}
client = Client(router=router,
roles=roles,
name="unauthenticated-client-one")
with pytest.raises(WelcomeAbortedError) as exc_info:
client.start()
client.stop()
exception = exc_info.value
message = str(exception)
assert ("no principal with authid \"not-an-expected-user\" exists"
in message)
assert "wamp.error.not_authorized" in message
def test_connection_is_challenged(router):
os.environ['WAMPYSECRET'] = "prq7+YkJ1/KlW1X0YczMHw=="
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'peter',
}
message_handler = CollectingMessageHandler()
client = Client(router=router,
roles=roles,
message_handler=message_handler,
name="unauthenticated-client")
client.start()
messages = wait_for_messages(client, 2)
# expect a Challenge and Welcome message
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
client.stop()
# now also expect a Goodbye message
assert len(messages) == 3
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
assert messages[2][0] == Goodbye.WAMP_CODE
def test_ipv6_websocket_connection(self, config_path, router):
service = DateService(url=router.url)
with service:
wait_for_registrations(service, 1)
client = Client(url=router.url)
with client:
result = client.rpc.get_todays_date()
today = date.today()
assert result == today.isoformat()
def test_connection_exits_if_missing_client_secret(router):
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'peter',
}
client = Client(
url=router.url, roles=roles, name="unauthenticated-client-two")
with pytest.raises(WampyError) as exc_info:
client.start()
exception = exc_info.value
message = str(exception)
assert "WAMPYSECRET" in message
def test_connection_exits_if_missing_client_secret(router):
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'peter',
}
client = Client(router=router,
roles=roles,
name="unauthenticated-client-two")
with pytest.raises(WampyError) as exc_info:
client.start()
exception = exc_info.value
message = str(exception)
assert "WAMPYSECRET" in message
def test_handle_value_error(unreliable_callee, router):
with Client(url=router.url, name="caller") as client:
with pytest.raises(WampyError) as exc_info:
client.rpc.get_foo(1, 2, three=3)
exception = exc_info.value
assert type(exception) is WampyError
message = str(exception)
assert "i do not like any of your values" in message
assert "(1, 2)" in message
assert "three" in message
def test_peter_cannot_call_get_foo(router, foo_service):
# `get_foo` can be registered but not called over the wampy role
os.environ['WAMPYSECRET'] = "prq7+YkJ1/KlW1X0YczMHw=="
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'peter',
}
client = Client(
url=router.url,
roles=roles,
message_handler_cls=CollectingMessageHandler,
name="unauthenticated-client-three",
)
client.start()
with pytest.raises(WampyError):
client.rpc.get_foo()
client.stop()
messages = wait_for_messages(client, 4)
# now also expect a Goodbye message
assert len(messages) == 4
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
assert messages[2][0] == Error.WAMP_CODE
assert messages[3][0] == Goodbye.WAMP_CODE
def test_incorrect_secret(router):
os.environ['WAMPYSECRET'] = "incorrect-password"
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'peter',
}
client = Client(router=router, roles=roles, name="bad-client")
with pytest.raises(WelcomeAbortedError) as exc_info:
client.start()
exception = exc_info.value
message = str(exception)
assert ("WAMP-CRA signature is invalid" in message)
assert "wamp.error.not_authorized" in message
def test_timeout_values(
self,
call_timeout,
wait,
reward,
router,
really_slow_service,
):
with Client(url=router.url, call_timeout=call_timeout) as client:
try:
resp = client.rpc.requires_patience(wait_in_seconds=wait)
except WampyTimeOutError:
resp = None
assert resp == reward
def test_ipv4_secure_websocket_connection_by_router_instance(
self, config_path, router):
try:
ssl.PROTOCOL_TLSv1_2
except AttributeError:
pytest.skip('Python Environment does not support TLS')
with DateService(router=router) as service:
wait_for_registrations(service, 1)
client = Client(router=router)
with client:
wait_for_session(client)
result = client.rpc.get_todays_date()
today = date.today()
assert result == today.isoformat()
def main():
port = config('PORT')
url = f'ws://*****:*****@example.com', 'blebs')
if isinstance(x, Error):
print('Error:', x.message)
else:
print(x)
x = client.call('authenticate', '*****@*****.**', 'blebs')
if isinstance(x, Error):
print('Error:', x.message)
else:
print(x)
client.stop()
def test_pings_and_missed_pongs(router, heartbeat, heartbeat_timeout, sleep,
expected_missed_pongs):
with patch('wampy.transports.websocket.connection.heartbeat', heartbeat):
with patch('wampy.transports.websocket.connection.heartbeat_timeout',
heartbeat_timeout):
with Client(url=router.url) as client:
wait_for_session(client)
assert client.is_pinging is True
ws = client.session.connection
assert ws.missed_pongs == 0
# this prevents Pongs being put into the shared queue
with patch.object(ws, 'handle_pong'):
async_adapter.sleep(sleep)
assert client.is_pinging is False
assert ws.missed_pongs == expected_missed_pongs
def test_cannot_publish_args_to_topic(foo_subscriber, router):
assert foo_subscriber.call_count == 0
client = Client(url=router.url)
with client:
with pytest.raises(WampyError):
client.publish("foo", )
assert foo_subscriber.call_count == 0
with pytest.raises(WampyError):
client.publish("foo", "foobar")
assert foo_subscriber.call_count == 0
even_more_args = range(100)
with pytest.raises(WampyError):
client.publish(even_more_args)
assert foo_subscriber.call_count == 0
def test_nameko_service_rpc_methods_are_called_by_any_wampy_client(
runner_factory, router, config_path):
wamp_client = Client(router=router)
config = {
WAMP_CONFIG_KEY: {
'config_path': config_path,
}
}
runner = runner_factory(config, WampServiceA)
runner.start()
assert WampServiceA.messages == []
container = get_container(runner, WampServiceA)
with wamp_client as client:
wait_for_session(client)
wait_for_registrations(container, number_of_registrations=1)
wait_for_subscriptions(container, number_of_subscriptions=2)
result = client.rpc.spam_call(cheese="cheddar", eggs="ducks")
assert result == "spam"
def waiting_for_the_message():
assert len(WampServiceA.messages) == 1
assert WampServiceA.messages == [((), {
u'cheese': u'cheddar',
u'eggs': u'ducks'
})]
assert_stops_raising(waiting_for_the_message)
container.stop()
WampServiceA.messages = []
def test_app_runner(self, router, config_path):
apps = [
'docs.examples.services:DateService',
'docs.examples.services:BinaryNumberService',
'docs.examples.services:FooService',
]
runner = run(apps, config_path=config_path, router=router)
# now check we can call these wonderful services
client = Client(router=router)
with client:
date = client.rpc.get_todays_date()
binary_number = client.rpc.get_binary_number(46)
foo = client.rpc.get_foo()
print("stopping all services gracefully")
runner.stop()
print("services have stopped")
assert date == datetime.date.today().isoformat()
assert binary_number == '0b101110'
assert foo == 'foo'
def test_pinging(router):
with patch('wampy.transports.websocket.connection.heartbeat', 1):
with patch('wampy.transports.websocket.connection.heartbeat_timeout',
2):
client = Client(router.url)
client.start()
wait_for_session(client)
assert client.is_pinging
ws = client.session.connection
assert ws.missed_pongs == 0
async_adapter.sleep(10)
assert ws.missed_pongs == 0
client.stop()
def test_cannot_publish_args_to_topic(foo_subscriber, router):
assert foo_subscriber.call_count == 0
client = Client(url=router.url)
with client:
with pytest.raises(WampyError):
client.publish("foo",)
assert foo_subscriber.call_count == 0
with pytest.raises(WampyError):
client.publish("foo", "foobar")
assert foo_subscriber.call_count == 0
even_more_args = range(100)
with pytest.raises(WampyError):
client.publish(even_more_args)
assert foo_subscriber.call_count == 0
def test_peter_cannot_call_get_foo(router, foo_service):
# `get_foo` can be registered but not called over the wampy role
os.environ['WAMPYSECRET'] = "prq7+YkJ1/KlW1X0YczMHw=="
roles = {
'roles': {
'subscriber': {},
'publisher': {},
'callee': {},
'caller': {},
},
'authmethods': ['wampcra'],
'authid': 'peter',
}
message_handler = CollectingMessageHandler()
client = Client(
router=router,
roles=roles,
message_handler=message_handler,
name="unauthenticated-client-three",
)
client.start()
with pytest.raises(NotAuthorisedError):
client.rpc.get_foo()
client.stop()
messages = wait_for_messages(client, 4)
# now also expect a Goodbye message
assert len(messages) == 4
assert messages[0][0] == Challenge.WAMP_CODE
assert messages[1][0] == Welcome.WAMP_CODE
assert messages[2][0] == Error.WAMP_CODE
assert messages[3][0] == Goodbye.WAMP_CODE
def test_rpc_with_args_but_no_kwargs(self, hello_service, router):
caller = Client(router=router)
with caller:
response = caller.rpc.say_hello("Simon")
assert response == "Hello Simon"
def test_rpc_with_no_args_but_a_default_kwarg(self, hello_service, router):
caller = Client(router=router)
with caller:
response = caller.rpc.say_greeting("Simon")
assert response == "hola to Simon"
def test_call_with_args_and_kwargs(self, hello_service, router):
caller = Client(router=router)
with caller:
response = caller.call("say_greeting", "Simon", greeting="watcha")
assert response == "watcha to Simon"
def test_call_with_args_but_no_kwargs(self, hello_service, router):
caller = Client(url=router.url)
with caller:
response = caller.call("say_hello", "Simon")
assert response == "Hello Simon"
def test_call_with_args_and_kwargs(self, hello_service, router):
caller = Client(url=router.url)
with caller:
response = caller.call("say_greeting", "Simon", greeting="watcha")
assert response == "watcha to Simon"
def test_publish_kwargs_to_topic(foo_subscriber, router):
assert foo_subscriber.call_count == 0
client = Client(url=router.url)
client.start()
client.publish(topic="foo", message="foobar")
def check_call_count():
assert foo_subscriber.call_count == 1
assert_stops_raising(check_call_count)
client.publish(topic="foo", message="foobar")
client.publish(topic="foo", message="spam")
client.publish(topic="foo", message="ham")
def check_call_count():
assert foo_subscriber.call_count == 4
assert_stops_raising(check_call_count)
client.stop()
def client(router):
with Client(router=router) as client:
yield client
