def test_publish_message_validator_factory_invalid_ack_fails_validation( faker: Faker, ): with_validation: Decorator = publish_message_validator_factory( message=Message( name=faker.word(), payload={ "type": "object", "properties": { "hello": { "type": "string" } }, }, x_ack=MessageAck( args={ "type": "object", "properties": { "acknowledged": { "type": "string" } }, "required": ["acknowledged"], }), )) @with_validation def handler(message: Mapping) -> Mapping[str, str]: assert "hello" in message return {"not-acknowledged": faker.pystr()} with pytest.raises(MessageAckValidationException): handler({"hello": faker.pystr()})
def test_validate_ack_args_with_tuple_schema_and_multiple_invalid_args( faker: Faker, ): with pytest.raises(MessageAckValidationException): validate_ack_args( ({ "hello": faker.pystr() }, faker.pyint()), MessageAck( args={ "type": "array", "prefixItems": [ { "type": "object", "properties": { "hello": { "type": "string" } }, }, { "type": "string" }, ], }), )
def test_publish_message_validator_factory_validates_valid_args_and_acks_successfully( faker: Faker, ): with_validation: Decorator = publish_message_validator_factory( message=Message( name=faker.word(), payload={ "type": "object", "properties": { "hello": { "type": "string" } }, }, x_ack=MessageAck( args={ "type": "object", "properties": { "acknowledged": { "type": "string" } }, "required": ["acknowledged"], }), )) @with_validation def handler(message: Mapping) -> Mapping[str, str]: assert "hello" in message return {"acknowledged": faker.pystr()} handler({"hello": faker.pystr()}) assert True
def test_make_subscription_task_with_no_message_payload_but_ack( server_info: Info, faker: Faker): namespace = f"/{faker.pystr()}" message = Message( name=faker.word(), x_ack=MessageAck(args={ "type": "string", "enum": [faker.pystr(), faker.pystr()], }), ) spec = AsyncApiSpec( asyncapi=faker.pystr(), info=server_info, channels={ namespace: Channel(subscribe=Operation(message=OneOfMessages( one_of=[message]), )) }, ) server = new_mock_asynction_socket_io(spec) task = server.make_subscription_task(message=message, namespace=namespace) with patch.object(server, "emit") as emit_mock: task() emit_mock.assert_called_once_with(message.name, None, namespace=namespace, callback=_noop_handler)
def test_validate_ack_args_with_tuple_schema_and_multiple_valid_args( faker: Faker, ): validate_ack_args( ({ "hello": faker.pystr() }, faker.pyint()), MessageAck( args={ "type": "array", "prefixItems": [ { "type": "object", "properties": { "hello": { "type": "string" } } }, { "type": "number" }, ], }), ) assert True
def test_publish_message_validator_factory_skips_ack_validation_if_handler_returns_none( faker: Faker, ): with_validation: Decorator = publish_message_validator_factory( message=Message( name=faker.word(), payload={ "type": "object", "properties": { "hello": { "type": "string" } }, }, x_ack=MessageAck( args={ "type": "object", "properties": { "acknowledged": { "type": "string" } }, "required": ["acknowledged"], }), )) @with_validation def handler(message: Mapping) -> None: assert "hello" in message handler({"hello": faker.pystr()}) assert True
def test_validate_ack_args_with_array_schema_and_single_valid_arg( faker: Faker, ): validate_ack_args( (faker.pylist(value_types=[str]), ), MessageAck(args={ "type": "array", "items": { "type": "string" }, }), ) assert True
def test_validate_ack_args_with_array_schema_and_single_invalid_arg( faker: Faker, ): with pytest.raises(MessageAckValidationException): validate_ack_args( (faker.pylist(value_types=[int]), ), MessageAck(args={ "type": "array", "items": { "type": "string" }, }), ) assert True
def test_validate_ack_args_with_single_object_schema_and_multiple_valid_args( faker: Faker, ): with pytest.raises(MessageAckValidationException): validate_ack_args( tuple([{ "hello": faker.pystr() }] * faker.pyint(min_value=2, max_value=10)), MessageAck(args={ "type": "object", "properties": { "hello": { "type": "string" } }, }), )
def test_validate_ack_args_with_single_object_schema_and_single_invalid_arg( faker: Faker, ): with pytest.raises(MessageAckValidationException): validate_ack_args( ({ "hello": faker.pyint() }, ), MessageAck(args={ "type": "object", "properties": { "hello": { "type": "string" } } }), )
def test_validate_ack_args_with_single_object_schema_and_single_valid_arg( faker: Faker, ): validate_ack_args( ({ "hello": faker.pystr() }, ), MessageAck(args={ "type": "object", "properties": { "hello": { "type": "string" } } }), ) assert True
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_make_subscription_task_with_message_payload_and_ack( server_info: Info, faker: Faker): namespace = f"/{faker.pystr()}" message = Message( name=faker.word(), payload={ "type": "object", "properties": { "foo": { "type": "string", "enum": [faker.pystr(), faker.pystr()], }, "bar": { "type": "number", "minimum": 10, "maximum": 20, }, }, "required": ["foo", "bar"], }, x_ack=MessageAck(args={ "type": "string", "enum": [faker.pystr(), faker.pystr()], }), ) spec = AsyncApiSpec( asyncapi=faker.pystr(), info=server_info, channels={ namespace: Channel(subscribe=Operation(message=OneOfMessages( one_of=[message]), )) }, ) server = new_mock_asynction_socket_io(spec) task = server.make_subscription_task(message=message, namespace=namespace) with patch.object(server, "emit") as emit_mock: task() emit_mock.assert_called_once_with(message.name, ANY, namespace=namespace, callback=_noop_handler) _, data = emit_mock.call_args[0] jsonschema.validate(data, message.payload) assert True
def test_emit_event_wraps_callback_with_validator(super_method_mock: mock.Mock, server_info: Info, faker: Faker): namespace = f"/{faker.pystr()}" event_name = faker.pystr() spec = AsyncApiSpec( asyncapi=faker.pystr(), info=server_info, channels={ namespace: Channel(subscribe=Operation(message=OneOfMessages(one_of=[ Message( name=event_name, payload={"type": "number"}, x_ack=MessageAck(args={"type": "boolean"}), ) ]), )) }, ) server = AsynctionSocketIO(spec, True, True, [], None, None) def actual_callback(*args): # dummy callback pass server.emit(event_name, faker.pyint(), namespace=namespace, callback=actual_callback) super_method_mock.assert_called_once() *_, kwargs = super_method_mock.call_args callback_with_validation = kwargs["callback"] callback_args = [faker.pystr() ] # invalid callback args (should have been a boolean) # actual callback has no validation -- hence it does not fail actual_callback(*callback_args) with pytest.raises(MessageAckValidationException): callback_with_validation(*callback_args)
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_callback_validator_factory_invalid_callback_args_fail_validation( faker: Faker, ): with_validation: Decorator = callback_validator_factory(message=Message( name=faker.word(), x_ack=MessageAck( args={ "type": "object", "properties": { "acknowledged": { "type": "string" } }, "required": ["acknowledged"], }), )) @with_validation def callback(message: Mapping) -> None: assert "not-acknowledged" in message with pytest.raises(MessageAckValidationException): callback({"not-acknowledged": faker.pystr()})
def test_callback_validator_factory_validates_valid_callback_args_successfully( faker: Faker, ): with_validation: Decorator = callback_validator_factory(message=Message( name=faker.word(), x_ack=MessageAck( args={ "type": "object", "properties": { "acknowledged": { "type": "string" } }, "required": ["acknowledged"], }), )) @with_validation def callback(message: Mapping) -> None: assert "acknowledged" in message callback({"acknowledged": faker.pystr()}) assert True