def test_envelope_context_raises_with_public_id_specified_twice():
"""Test the EnvelopeContext constructor, negative"""
with pytest.raises(
ValueError,
match="Cannot define connection_id explicitly and in URI."):
EnvelopeContext(
uri=URI("connection/author/connection_name/0.1.0"),
connection_id=PublicId("author", "connection_name", "0.1.0"),
)
with pytest.raises(ValueError,
match="Cannot define skill_id explicitly and in URI."):
EnvelopeContext(
uri=URI("skill/author/skill_name/0.1.0"),
skill_id=PublicId("author", "skill_name", "0.1.0"),
)
async def to_envelope(self, request: web.Request) -> Envelope:
"""
Convert a webhook request object into an Envelope containing an HttpMessage `from the 'http' Protocol`.
:param request: the webhook request
:return: The envelop representing the webhook request
"""
payload_bytes = await request.read()
version = str(request.version[0]) + "." + str(request.version[1])
context = EnvelopeContext(uri=URI("aea/mail/base.py"))
http_message = HttpMessage(
performative=HttpMessage.Performative.REQUEST,
method=request.method,
url=str(request.url),
version=version,
headers=json.dumps(dict(request.headers)),
bodyy=payload_bytes if payload_bytes is not None else b"",
)
envelope = Envelope(
to=self.agent_address,
sender=request.remote,
protocol_id=PublicId.from_str("fetchai/http:0.3.0"),
context=context,
message=http_message,
)
return envelope
async def to_envelope(self, request: web.Request) -> Envelope:
"""
Convert a webhook request object into an Envelope containing an HttpMessage `from the 'http' Protocol`.
:param request: the webhook request
:return: The envelop representing the webhook request
"""
payload_bytes = await request.read()
version = str(request.version[0]) + "." + str(request.version[1])
context = EnvelopeContext(uri=URI("aea/mail/base.py"))
http_message = HttpMessage(
performative=HttpMessage.Performative.REQUEST,
method=request.method,
url=str(request.url),
version=version,
headers=json.dumps(dict(request.headers)),
bodyy=payload_bytes if payload_bytes is not None else b"",
dialogue_reference=self._dialogues.
new_self_initiated_dialogue_reference(),
)
http_message.counterparty = self.agent_address
http_dialogue = self._dialogues.update(http_message)
assert http_dialogue is not None, "Could not create dialogue."
envelope = Envelope(
to=http_message.counterparty,
sender=http_message.sender,
protocol_id=http_message.protocol_id,
context=context,
message=http_message,
)
return envelope
def to_envelope(self, connection_id: PublicId, agent_address: str) -> Envelope:
"""
Process incoming API request by packaging into Envelope and sending it in-queue.
The Envelope's message body contains the "performative", "path", "params", and "payload".
:param http_method: the http method
:param url: the url
:param param: the parameter
:param body: the body
"""
uri = URI(self.full_url_pattern)
context = EnvelopeContext(connection_id=connection_id, uri=uri)
http_message = HttpMessage(
dialogue_reference=("", ""),
target=0,
message_id=1,
performative=HttpMessage.Performative.REQUEST,
method=self.method,
url=self.full_url_pattern,
headers=self.parameters.header.as_string(),
bodyy=self.body.encode() if self.body is not None else b"",
version="",
)
envelope = Envelope(
to=agent_address,
sender=self.id,
protocol_id=PublicId.from_str("fetchai/http:0.1.0"),
context=context,
message=HttpSerializer().encode(http_message),
)
return envelope
def test_envelope_skill_id():
"""Test the property Envelope.skill_id."""
envelope_context = EnvelopeContext(uri=URI("author/skill_name/0.1.0"))
envelope = Envelope(
to="to",
sender="sender",
protocol_id=PublicId("author", "name", "0.1.0"),
message=b"message",
context=envelope_context,
)
assert envelope.skill_id == PublicId("author", "skill_name", "0.1.0")
def test_envelope_connection_id():
"""Test the property Envelope.connection_id."""
envelope_context = EnvelopeContext(
uri=URI("connection/author/connection_name/0.1.0"))
envelope = Envelope(
to="to",
sender="sender",
protocol_specification_id=PublicId("author", "name", "0.1.0"),
message=b"message",
context=envelope_context,
)
assert envelope.connection_id == PublicId("author", "connection_name",
"0.1.0")
def test_uri():
"""Testing the uri initialisation."""
uri_raw = "http://*****:*****@NetLoc:80/path;param?query=arg#frag"
uri = URI(uri_raw=uri_raw)
assert uri_raw == str(uri)
assert uri.scheme == "http"
assert uri.netloc == "user:pwd@NetLoc:80"
assert uri.path == "/path"
assert uri.params == "param"
assert uri.query == "query=arg"
assert uri.fragment == "frag"
assert uri.host == "netloc"
assert uri.port == 80
assert uri.username == "user"
assert uri.password == "pwd"
def test_protobuf_envelope_serializer():
"""Test Protobuf envelope serializer."""
serializer = ProtobufEnvelopeSerializer()
# connection id is None because it is not included in the encoded envelope
envelope_context = EnvelopeContext(connection_id=None, uri=URI("/uri"))
expected_envelope = Envelope(
to="to",
sender="sender",
protocol_id=PublicId("author", "name", "0.1.0"),
message=b"message",
context=envelope_context,
)
encoded_envelope = serializer.encode(expected_envelope)
actual_envelope = serializer.decode(encoded_envelope)
assert actual_envelope == expected_envelope
def test_envelope_skill_id_raises_value_error(caplog):
"""Test the property Envelope.skill_id raises ValueError if the URI is not a public id.."""
with caplog.at_level(logging.DEBUG, logger="aea.mail.base"):
bad_uri = "author/skill_name/bad_version"
envelope_context = EnvelopeContext(uri=URI(bad_uri))
envelope = Envelope(
to="to",
sender="sender",
protocol_id=PublicId("author", "name", "0.1.0"),
message=b"message",
context=envelope_context,
)
assert envelope.skill_id is None
assert (
f"URI - {bad_uri} - not a valid skill id." in caplog.text
), f"Cannot find message in output: {caplog.text}"
def test_envelope_skill_id_raises_value_error_wrong_package_type():
"""Test the property Envelope.skill_id raises ValueError if the URI is not a valid package type."""
with unittest.mock.patch.object(aea.mail.base._default_logger,
"debug") as mock_logger_method:
invalid_uri = "protocol/author/skill_name/0.1.0"
envelope_context = EnvelopeContext(uri=URI(invalid_uri))
envelope = Envelope(
to="to",
sender="sender",
protocol_specification_id=PublicId("author", "name", "0.1.0"),
message=b"message",
context=envelope_context,
)
assert envelope.skill_id is None
mock_logger_method.assert_called_with(
f"URI - {invalid_uri} - not a valid package_id id. Error: Invalid package type protocol in uri for envelope context."
)
def test_envelope_skill_id_raises_value_error():
"""Test the property Envelope.skill_id raises ValueError if the URI is not a package id.."""
with unittest.mock.patch.object(aea.mail.base._default_logger,
"debug") as mock_logger_method:
bad_uri = "skill/author/skill_name/bad_version"
envelope_context = EnvelopeContext(uri=URI(bad_uri))
envelope = Envelope(
to="to",
sender="sender",
protocol_specification_id=PublicId("author", "name", "0.1.0"),
message=b"message",
context=envelope_context,
)
assert envelope.skill_id is None
mock_logger_method.assert_called_with(
f"URI - {bad_uri} - not a valid package_id id. Error: Input '{bad_uri}' is not well formatted."
)
def test_error_unsupported_skill_when_skill_id_is_none(self):
"""Test the 'send_unsupported_skill' when the skill id in the envelope is None."""
skill_id = PublicId.from_str("author/skill:0.1.0")
protocol_id = PublicId.from_str("author/name:0.1.0")
envelope = Envelope(
to="",
sender="",
protocol_id=protocol_id,
message=b"",
context=EnvelopeContext(uri=URI(skill_id.to_uri_path)),
)
with unittest.mock.patch.object(self.skill_context.outbox,
"put_message"):
with unittest.mock.patch.object(self.skill_context._logger,
"warning") as mock_logger_warning:
self.my_error_handler.send_unsupported_skill(envelope)
mock_logger_warning.assert_called_with(
f"Cannot handle envelope: no active handler registered for the protocol_id='{protocol_id}' and skill_id='{skill_id}'."
)
def to_envelope_and_set_id(
self,
connection_id: PublicId,
agent_address: str,
dialogues: HttpDialogues,
) -> Envelope:
"""
Process incoming API request by packaging into Envelope and sending it in-queue.
:param connection_id: id of the connection
:param agent_address: agent's address
:param dialogue_reference: new dialog refernece for envelope
:return: envelope
"""
url = (self.full_url_pattern if self.parameters.query == {} else
self.full_url_pattern + "?" + urlencode(self.parameters.query))
uri = URI(self.full_url_pattern)
context = EnvelopeContext(connection_id=connection_id, uri=uri)
http_message = HttpMessage(
dialogue_reference=dialogues.new_self_initiated_dialogue_reference(
),
performative=HttpMessage.Performative.REQUEST,
method=self.method,
url=url,
headers=self.parameters.header,
bodyy=self.body if self.body is not None else b"",
version="",
)
http_message.counterparty = agent_address
dialogue = cast(Optional[HttpDialogue], dialogues.update(http_message))
assert dialogue is not None, "Could not create dialogue for message={}".format(
http_message)
self.id = dialogue.incomplete_dialogue_label
envelope = Envelope(
to=agent_address,
sender=str(connection_id),
protocol_id=http_message.protocol_id,
context=context,
message=http_message,
)
return envelope
def test_envelope_skill_id_raises_value_error():
"""Test the property Envelope.skill_id raises ValueError if the URI is not a public id.."""
with unittest.mock.patch.object(aea.mail.base.logger,
"debug") as mock_logger_method:
# with caplog.at_level(logging.DEBUG, logger="aea.mail.base"):
bad_uri = "author/skill_name/bad_version"
envelope_context = EnvelopeContext(uri=URI(bad_uri))
envelope = Envelope(
to="to",
sender="sender",
protocol_id=PublicId("author", "name", "0.1.0"),
message=b"message",
context=envelope_context,
)
assert envelope.skill_id is None
# assert (
# f"URI - {bad_uri} - not a valid skill id." in caplog.text
# ), f"Cannot find message in output: {caplog.text}"
mock_logger_method.assert_called_with(
f"URI - {bad_uri} - not a valid skill id.")
def to_envelope_and_set_id(
self,
connection_id: PublicId,
agent_address: str,
dialogues: HttpDialogues,
) -> Envelope:
"""
Process incoming API request by packaging into Envelope and sending it in-queue.
:param connection_id: id of the connection
:param agent_address: agent's address
:param dialogue_reference: new dialog refernece for envelope
:return: envelope
"""
url = self.full_url_pattern
uri = URI(self.full_url_pattern)
context = EnvelopeContext(connection_id=connection_id, uri=uri)
http_message, http_dialogue = dialogues.create(
counterparty=agent_address,
performative=HttpMessage.Performative.REQUEST,
method=self.method,
url=url,
headers=self.parameters.header,
body=self.body if self.body is not None else b"",
version="",
)
dialogue = cast(HttpDialogue, http_dialogue)
self.id = dialogue.incomplete_dialogue_label
envelope = Envelope(
to=http_message.to,
sender=http_message.sender,
context=context,
message=http_message,
)
return envelope
def test_uri_eq():
"""Testing the uri __eq__ function."""
uri_raw = "http://*****:*****@NetLoc:80/path;param?query=arg#frag"
uri = URI(uri_raw=uri_raw)
assert uri == uri
