def test_register_handlers_registers_connection_handler_with_bindings_validation(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(bindings=ChannelBindings(
ws=WebSocketsChannelBindings(method="GET", )), )
},
)
server = new_mock_asynction_socket_io(spec)
flask_app = Flask(__name__)
server._register_handlers()
_, registered_handler, _ = server.handlers[0]
handler_with_validation = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(registered_handler)
with flask_app.test_client() as c:
with patch.object(server, "start_background_task"):
c.post() # Inject invalid POST request
actual_handler() # actual handler does not raise validation errors
with pytest.raises(BindingsValidationException):
handler_with_validation()
def test_register_handlers_adds_payload_validator_if_validation_is_enabled(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(publish=Operation(message=OneOfMessages(one_of=[
Message(
name=faker.word(),
payload={"type": "string"},
x_handler=faker.pystr(),
)
]), ))
},
)
server = new_mock_asynction_socket_io(spec)
server._register_handlers()
_, registered_handler, _ = server.handlers[0]
handler_with_validation = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(handler_with_validation)
args = (faker.pyint(), )
actual_handler(*args) # actual handler does not raise validation errors
with pytest.raises(PayloadValidationException):
handler_with_validation(*args)
def test_register_handlers_skips_payload_validator_if_validation_is_disabled(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
event_name = faker.word()
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(publish=Operation(message=OneOfMessages(one_of=[
Message(
name=event_name,
payload={"type": "string"},
x_handler="tests.fixtures.handlers.ping",
)
]), ))
},
)
server = AsynctionSocketIO(spec, False, True, [], None, None)
server._register_handlers()
_, registered_handler, _ = server.handlers[0]
handler_with_validation = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(handler_with_validation)
assert handler_with_validation == actual_handler
args = (faker.pyint(), )
handler_with_validation(*args) # handler does not raise validation errors
assert True
def test_register_handlers_registers_callables_with_correct_event_name_and_namespace(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
event_name = faker.word()
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(publish=Operation(message=OneOfMessages(one_of=[
Message(
name=event_name,
payload={"type": "object"},
x_handler="tests.fixtures.handlers.ping",
)
]), ))
},
)
server = AsynctionSocketIO(spec, True, True, [], None, None)
server._register_handlers()
assert len(server.handlers) == 2 # connection handler is also registered
ping_handler_entry, connect_handler_entry = server.handlers
registered_event, registered_handler, registered_namespace = ping_handler_entry
assert registered_event == event_name
assert deep_unwrap(registered_handler) == ping
assert registered_namespace == namespace
connection_event, connection_handler, registered_namespace = connect_handler_entry
assert connection_event == "connect"
assert deep_unwrap(connection_handler) == _noop_handler
assert registered_namespace == namespace
def test_register_handlers_registers_noop_handler_for_message_with_no_ack(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
event_name = faker.word()
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(publish=Operation(message=OneOfMessages(one_of=[
Message(
name=event_name,
payload={"type": "object"},
x_handler=faker.pystr(),
)
]), ))
},
)
server = new_mock_asynction_socket_io(spec)
server._register_handlers()
assert len(server.handlers) == 2 # connect handler included as well
registered_event, registered_handler, registered_namespace = server.handlers[
0]
assert registered_event == event_name
assert registered_namespace == namespace
handler = deep_unwrap(registered_handler)
assert handler == _noop_handler
def test_register_handlers_registers_channel_handlers(
server_info: Info,
faker: Faker,
):
namespace = f"/{faker.pystr()}"
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(x_handlers=ChannelHandlers(
connect="tests.fixtures.handlers.connect",
disconnect="tests.fixtures.handlers.disconnect",
error="tests.fixtures.handlers.some_error",
))
},
)
server = AsynctionSocketIO(spec, True, True, [], None, None)
server._register_handlers()
assert server.exception_handlers[namespace] == some_error
for event_name, handler, handler_namespace in server.handlers:
assert handler_namespace == namespace
unwrapped = deep_unwrap(handler)
if event_name == "connect":
assert unwrapped == connect
else:
assert unwrapped == disconnect
def test_register_namespace_handlers_includes_server_security_validation():
channel_handlers = ChannelHandlers(
connect="tests.fixtures.handlers.connect")
spec = AsyncApiSpec(
asyncapi="2.3.0",
info=Info("test", "1.0.0"),
servers={
"test":
Server("https://localhost/", ServerProtocol.WSS, [{
"basic": []
}])
},
channels={GLOBAL_NAMESPACE: Channel(x_handlers=channel_handlers)},
components=Components(
security_schemes={
"basic":
SecurityScheme(
type=SecuritySchemesType.HTTP,
scheme=HTTPAuthenticationScheme.BASIC,
x_basic_info_func="tests.fixtures.handlers.basic_info",
)
}),
)
server = AsynctionSocketIO(spec, False, True,
spec.servers.get("test").security, None, None)
server._register_namespace_handlers(
GLOBAL_NAMESPACE,
channel_handlers,
None,
None, # No channel security requirements
)
event_name, registered_handler, _ = server.handlers[0]
assert event_name == "connect"
handler_with_security = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(handler_with_security)
with Flask(__name__).test_client() as c:
c.post() # Inject invalid POST request
actual_handler()
with pytest.raises(SecurityException):
handler_with_security() # handler raises security exception
assert True
def test_register_namespace_handlers_omits_bindings_validator_if_validation_disabled(
):
channel_handlers = ChannelHandlers(
connect="tests.fixtures.handlers.connect")
channel_bindings = ChannelBindings(
ws=WebSocketsChannelBindings(method="GET", ))
server = AsynctionSocketIO(mock.Mock(), False, True, [], None, None)
server._register_namespace_handlers(GLOBAL_NAMESPACE, channel_handlers,
channel_bindings, [])
event_name, registered_handler, _ = server.handlers[0]
assert event_name == "connect"
handler_with_validation = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(handler_with_validation)
with Flask(__name__).test_client() as c:
c.post() # Inject invalid POST request
assert handler_with_validation == actual_handler
handler_with_validation() # handler does not raise validation errors
assert True
def test_register_handlers_adds_ack_validator_if_validation_is_enabled(
server_info: Info, faker: Faker):
namespace = f"/{faker.pystr()}"
event_name = faker.word()
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(publish=Operation(message=OneOfMessages(one_of=[
Message(
name=event_name,
payload={"type": "string"},
x_handler="tests.fixtures.handlers.ping_with_ack",
x_ack=MessageAck(
args={
"type": "object",
"properties": {
"ack": {
"type": "number"
}
},
"required": ["ack"],
}),
)
]), ))
},
)
server = AsynctionSocketIO(spec, True, True, [], None, None)
server._register_handlers()
_, registered_handler, _ = server.handlers[0]
handler_with_validation = deep_unwrap(registered_handler, depth=1)
actual_handler = deep_unwrap(handler_with_validation)
args = (faker.pystr(), ) # valid handler args
# actual handler does not raise validation errors, although it returns invalid data
actual_handler(*args)
with pytest.raises(MessageAckValidationException):
handler_with_validation(*args)
def test_register_handlers_registers_connection_handler(
server_info: Info, faker: Faker):
namespace = f"/{faker.pystr()}"
spec = AsyncApiSpec(asyncapi=faker.pystr(),
info=server_info,
channels={namespace: Channel()})
server = new_mock_asynction_socket_io(spec)
server._register_handlers()
assert len(server.handlers) == 1
registered_event, registered_handler, registered_namespace = server.handlers[
0]
assert registered_event == "connect"
assert deep_unwrap(registered_handler) == _noop_handler
assert registered_namespace == namespace
def test_register_handlers_registers_valid_handler_for_message_with_ack(
server_info: Info, faker: Faker):
namespace = f"/{faker.pystr()}"
event_name = faker.word()
ack_schema = {
"type": "object",
"properties": {
"foo": {
"type": "string",
"enum": [faker.pystr(), faker.pystr()],
},
"bar": {
"type": "number",
"minimum": 10,
"maximum": 20,
},
},
"required": ["foo", "bar"],
}
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(publish=Operation(message=OneOfMessages(one_of=[
Message(
name=event_name,
payload={"type": "object"},
x_handler=faker.pystr(),
x_ack=MessageAck(args=ack_schema),
)
]), ))
},
)
server = new_mock_asynction_socket_io(spec)
server._register_handlers()
assert len(server.handlers) == 2 # connect handler included as well
registered_event, registered_handler, registered_namespace = server.handlers[
0]
assert registered_event == event_name
assert registered_namespace == namespace
handler = deep_unwrap(registered_handler)
ack = handler(faker.pydict())
jsonschema.validate(ack, ack_schema)
assert True
def test_init_app_registers_handlers_if_app_is_not_none(
server_info: Info, faker: Faker):
namespace = f"/{faker.pystr()}"
event_name = faker.pystr()
spec = AsyncApiSpec(
asyncapi=faker.pystr(),
info=server_info,
channels={
namespace:
Channel(publish=Operation(message=OneOfMessages(one_of=[
Message(
name=event_name,
payload={"type": "object"},
x_handler="tests.fixtures.handlers.ping",
)
]), ))
},
)
server = AsynctionSocketIO(spec, False, False, [], None, None)
app = Flask(__name__)
server.init_app(app)
_, registered_handler, _ = server.handlers[0]
actual_handler = deep_unwrap(registered_handler)
assert actual_handler == ping
