def setup(self):
"""Initialise the test case."""
self.identity = Identity("name", address="my_key")
self.agent_address = self.identity.address
self.host = get_host()
self.port = get_unused_tcp_port()
self.api_spec_path = os.path.join(
ROOT_DIR, "tests", "data", "petstore_sim.yaml"
)
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = PublicId.from_str("fetchai/http:0.4.0")
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=self.api_spec_path,
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.http_connection = HTTPServerConnection(
configuration=self.configuration, identity=self.identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.http_connection.connect())
self.connection_address = str(HTTPServerConnection.connection_id)
self._dialogues = HttpDialogues(self.connection_address)
self.original_timeout = self.http_connection.channel.RESPONSE_TIMEOUT
def setup_server(self):
"""Set up server connection."""
self.server_agent_address = "server_agent_address"
self.server_agent_identity = Identity(
"agent running server", address=self.server_agent_address
)
self.host = get_host()
self.port = get_unused_tcp_port()
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = PublicId.from_str("fetchai/http:0.4.0")
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=None, # do not filter on API spec
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.server = HTTPServerConnection(
configuration=self.configuration, identity=self.server_agent_identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.server.connect())
# skill side dialogues
self._server_dialogues = HttpDialogues(self.server_agent_address)
def setup_class(cls):
"""Initialise the class."""
cls.address = "my_key"
cls.host = get_host()
cls.port = get_unused_tcp_port()
cls.api_spec_path = os.path.join(ROOT_DIR, "tests", "data",
"petstore_sim.yaml")
cls.connection_id = PublicId("fetchai", "http_server", "0.1.0")
cls.protocol_id = PublicId("fetchai", "http", "0.1.0")
cls.http_connection = HTTPServerConnection(
address=cls.address,
host=cls.host,
port=cls.port,
api_spec_path=cls.api_spec_path,
connection_id=cls.connection_id,
restricted_to_protocols=set([cls.protocol_id]),
)
cls.loop = asyncio.new_event_loop()
cls.http_connection.loop = cls.loop
value = cls.loop.run_until_complete(cls.http_connection.connect())
assert value is None
assert cls.http_connection.connection_status.is_connected
assert not cls.http_connection.channel.is_stopped
cls.t = Thread(target=cls.loop.run_forever)
cls.t.start()
def setup_server(self):
"""Set up server connection."""
self.server_agent_address = "server_agent_address"
self.server_agent_identity = Identity(
"agent running server", address=self.server_agent_address)
self.host = get_host()
self.port = get_unused_tcp_port()
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = HttpMessage.protocol_id
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=None, # do not filter on API spec
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.server = HTTPServerConnection(
configuration=self.configuration,
identity=self.server_agent_identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.server.connect())
# skill side dialogues
def role_from_first_message( # pylint: disable=unused-argument
message: Message,
receiver_address: Address) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return HttpDialogue.Role.SERVER
self._server_dialogues = HttpDialogues(
self.server_agent_address,
role_from_first_message=role_from_first_message)
def setup_class(cls):
"""Initialise the class and test connect."""
cls.address = "my_key"
cls.host = get_host()
cls.port = get_unused_tcp_port()
cls.api_spec_path = os.path.join(ROOT_DIR, "tests", "data",
"petstore_sim.yaml")
cls.connection_id = PublicId("fetchai", "http_server", "0.1.0")
cls.protocol_id = PublicId("fetchai", "http", "0.1.0")
cls.http_connection = HTTPServerConnection(
address=cls.address,
host=cls.host,
port=cls.port,
api_spec_path=cls.api_spec_path,
connection_id=cls.connection_id,
restricted_to_protocols=set([cls.protocol_id]),
)
assert cls.http_connection.channel.is_stopped
cls.http_connection.channel.connect()
assert not cls.http_connection.channel.is_stopped
class TestHTTPServer:
"""Tests for HTTPServer connection."""
async def request(self, method: str, path: str, **kwargs) -> ClientResponse:
"""
Make a http request.
:param method: HTTP method: GET, POST etc
:param path: path to request on server. full url constructed automatically
:return: http response
"""
try:
url = f"http://{self.host}:{self.port}{path}"
async with aiohttp.ClientSession() as session:
async with session.request(method, url, **kwargs) as resp:
await resp.read()
return resp
except Exception:
print_exc()
raise
def setup(self):
"""Initialise the test case."""
self.identity = Identity("name", address="my_key")
self.agent_address = self.identity.address
self.host = get_host()
self.port = get_unused_tcp_port()
self.api_spec_path = os.path.join(
ROOT_DIR, "tests", "data", "petstore_sim.yaml"
)
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = PublicId.from_str("fetchai/http:0.4.0")
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=self.api_spec_path,
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.http_connection = HTTPServerConnection(
configuration=self.configuration, identity=self.identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.http_connection.connect())
self.connection_address = str(HTTPServerConnection.connection_id)
self._dialogues = HttpDialogues(self.connection_address)
self.original_timeout = self.http_connection.channel.RESPONSE_TIMEOUT
@pytest.mark.asyncio
async def test_http_connection_disconnect_channel(self):
"""Test the disconnect."""
await self.http_connection.channel.disconnect()
assert self.http_connection.channel.is_stopped
def _get_message_and_dialogue(
self, envelope: Envelope
) -> Tuple[HttpMessage, HttpDialogue]:
message = cast(HttpMessage, envelope.message)
message = copy.copy(
message
) # TODO: fix; need to copy atm to avoid overwriting "is_incoming"
message.is_incoming = True # TODO: fix; should be done by framework
message.counterparty = envelope.sender # TODO: fix; should be done by framework
dialogue = cast(HttpDialogue, self._dialogues.update(message))
assert dialogue is not None
return message, dialogue
@pytest.mark.asyncio
async def test_get_200(self):
"""Test send get request w/ 200 response."""
request_task = self.loop.create_task(self.request("get", "/pets"))
envelope = await asyncio.wait_for(self.http_connection.receive(), timeout=20)
assert envelope
incoming_message, dialogue = self._get_message_and_dialogue(envelope)
message = HttpMessage(
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
performative=HttpMessage.Performative.RESPONSE,
version=incoming_message.version,
headers=incoming_message.headers,
message_id=incoming_message.message_id + 1,
target=incoming_message.message_id,
status_code=200,
status_text="Success",
bodyy=b"Response body",
)
message.counterparty = incoming_message.counterparty
assert dialogue.update(message)
response_envelope = Envelope(
to=envelope.sender,
sender=envelope.to,
protocol_id=envelope.protocol_id,
context=envelope.context,
message=message,
)
await self.http_connection.send(response_envelope)
response = await asyncio.wait_for(request_task, timeout=20,)
assert (
response.status == 200
and response.reason == "Success"
and await response.text() == "Response body"
)
@pytest.mark.asyncio
async def test_bad_performative_get_timeout_error(self):
"""Test send get request w/ 200 response."""
self.http_connection.channel.RESPONSE_TIMEOUT = 3
request_task = self.loop.create_task(self.request("get", "/pets"))
envelope = await asyncio.wait_for(self.http_connection.receive(), timeout=10)
assert envelope
incoming_message, dialogue = self._get_message_and_dialogue(envelope)
message = HttpMessage(
performative=HttpMessage.Performative.REQUEST,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=incoming_message.message_id,
message_id=incoming_message.message_id + 1,
method="post",
url="/pets",
version=incoming_message.version,
headers=incoming_message.headers,
bodyy=b"Request body",
)
message.counterparty = incoming_message.counterparty
assert not dialogue.update(message)
response_envelope = Envelope(
to=envelope.sender,
sender=envelope.to,
protocol_id=envelope.protocol_id,
context=envelope.context,
message=message,
)
with patch.object(self.http_connection.logger, "warning") as mock_logger:
await self.http_connection.send(response_envelope)
mock_logger.assert_any_call(
f"Could not create dialogue for message={message}"
)
response = await asyncio.wait_for(request_task, timeout=10)
assert (
response.status == 408
and response.reason == "Request Timeout"
and await response.text() == ""
)
@pytest.mark.asyncio
async def test_late_message_get_timeout_error(self):
"""Test send get request w/ 200 response."""
self.http_connection.channel.RESPONSE_TIMEOUT = 1
request_task = self.loop.create_task(self.request("get", "/pets"))
envelope = await asyncio.wait_for(self.http_connection.receive(), timeout=10)
assert envelope
incoming_message, dialogue = self._get_message_and_dialogue(envelope)
message = HttpMessage(
performative=HttpMessage.Performative.RESPONSE,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=incoming_message.message_id,
message_id=incoming_message.message_id + 1,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=200,
status_text="Success",
bodyy=b"Response body",
)
message.counterparty = incoming_message.counterparty
assert dialogue.update(message)
response_envelope = Envelope(
to=envelope.sender,
sender=envelope.to,
protocol_id=envelope.protocol_id,
context=envelope.context,
message=message,
)
await asyncio.sleep(1.5)
with patch.object(self.http_connection.logger, "warning") as mock_logger:
await self.http_connection.send(response_envelope)
mock_logger.assert_any_call(
RegexComparator(
"Dropping message=.* for incomplete_dialogue_label=.* which has timed out."
)
)
response = await asyncio.wait_for(request_task, timeout=10)
assert (
response.status == 408
and response.reason == "Request Timeout"
and await response.text() == ""
)
@pytest.mark.asyncio
async def test_post_201(self):
"""Test send get request w/ 200 response."""
request_task = self.loop.create_task(self.request("post", "/pets",))
envelope = await asyncio.wait_for(self.http_connection.receive(), timeout=20)
assert envelope
incoming_message, dialogue = self._get_message_and_dialogue(envelope)
message = HttpMessage(
performative=HttpMessage.Performative.RESPONSE,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=incoming_message.message_id,
message_id=incoming_message.message_id + 1,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=201,
status_text="Created",
bodyy=b"Response body",
)
message.counterparty = incoming_message.counterparty
assert dialogue.update(message)
response_envelope = Envelope(
to=envelope.sender,
sender=envelope.to,
protocol_id=envelope.protocol_id,
context=envelope.context,
message=message,
)
await self.http_connection.send(response_envelope)
response = await asyncio.wait_for(request_task, timeout=20,)
assert (
response.status == 201
and response.reason == "Created"
and await response.text() == "Response body"
)
@pytest.mark.asyncio
async def test_get_404(self):
"""Test send post request w/ 404 response."""
response = await self.request("get", "/url-non-exists")
assert (
response.status == 404
and response.reason == "Request Not Found"
and await response.text() == ""
)
@pytest.mark.asyncio
async def test_post_404(self):
"""Test send post request w/ 404 response."""
response = await self.request("get", "/url-non-exists", data="some data")
assert (
response.status == 404
and response.reason == "Request Not Found"
and await response.text() == ""
)
@pytest.mark.asyncio
async def test_get_408(self):
"""Test send post request w/ 404 response."""
await self.http_connection.connect()
self.http_connection.channel.RESPONSE_TIMEOUT = 0.1
response = await self.request("get", "/pets")
assert (
response.status == 408
and response.reason == "Request Timeout"
and await response.text() == ""
)
@pytest.mark.asyncio
async def test_post_408(self):
"""Test send post request w/ 404 response."""
self.http_connection.channel.RESPONSE_TIMEOUT = 0.1
response = await self.request("post", "/pets", data="somedata")
assert (
response.status == 408
and response.reason == "Request Timeout"
and await response.text() == ""
)
@pytest.mark.asyncio
async def test_send_connection_drop(self):
"""Test unexpected response."""
message = HttpMessage(
performative=HttpMessage.Performative.RESPONSE,
dialogue_reference=("", ""),
target=1,
message_id=2,
headers="",
version="",
status_code=200,
status_text="Success",
bodyy=b"",
)
message.counterparty = "to_key"
message.sender = "from_key"
envelope = Envelope(
to=message.counterparty,
sender=message.sender,
protocol_id=message.protocol_id,
message=message,
)
await self.http_connection.send(envelope)
@pytest.mark.asyncio
async def test_get_message_channel_not_connected(self):
"""Test error on channel get message if not connected."""
await self.http_connection.disconnect()
with pytest.raises(ValueError):
await self.http_connection.channel.get_message()
@pytest.mark.asyncio
async def test_fail_connect(self):
"""Test error on server connection."""
await self.http_connection.disconnect()
with patch.object(
self.http_connection.channel,
"_start_http_server",
side_effect=Exception("expected"),
):
await self.http_connection.connect()
assert not self.http_connection.is_connected
@pytest.mark.asyncio
async def test_server_error_on_send_response(self):
"""Test exception raised on response sending to the client."""
request_task = self.loop.create_task(self.request("post", "/pets",))
envelope = await asyncio.wait_for(self.http_connection.receive(), timeout=20)
assert envelope
incoming_message, dialogue = self._get_message_and_dialogue(envelope)
message = HttpMessage(
performative=HttpMessage.Performative.RESPONSE,
dialogue_reference=dialogue.dialogue_label.dialogue_reference,
target=incoming_message.message_id,
message_id=incoming_message.message_id + 1,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=201,
status_text="Created",
bodyy=b"Response body",
)
message.counterparty = incoming_message.counterparty
assert dialogue.update(message)
response_envelope = Envelope(
to=envelope.sender,
sender=envelope.to,
protocol_id=envelope.protocol_id,
context=envelope.context,
message=message,
)
with patch.object(Response, "from_message", side_effect=Exception("expected")):
await self.http_connection.send(response_envelope)
response = await asyncio.wait_for(request_task, timeout=20,)
assert response and response.status == 500 and response.reason == "Server Error"
@pytest.mark.asyncio
async def test_send_envelope_restricted_to_protocols_fail(self):
"""Test fail on send if envelope protocol not supported."""
message = HttpMessage(
performative=HttpMessage.Performative.RESPONSE,
dialogue_reference=("", ""),
target=1,
message_id=2,
version="1.0",
headers="",
status_code=200,
status_text="Success",
bodyy=b"Response body",
)
envelope = Envelope(
to="receiver",
sender="sender",
protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
message=message,
)
with patch.object(
self.http_connection.channel,
"restricted_to_protocols",
new=[HTTP_PROTOCOL_PUBLIC_ID],
):
with pytest.raises(ValueError):
await self.http_connection.send(envelope)
def teardown(self):
"""Teardown the test case."""
self.loop.run_until_complete(self.http_connection.disconnect())
self.http_connection.channel.RESPONSE_TIMEOUT = self.original_timeout
class TestClientServer:
"""Client-Server end-to-end test."""
def setup_server(self):
"""Set up server connection."""
self.identity = Identity("name", address="server")
self.host = get_host()
self.port = get_unused_tcp_port()
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = PublicId.from_str("fetchai/http:0.3.0")
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=None, # do not filter on API spec
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.server = HTTPServerConnection(
configuration=self.configuration,
identity=self.identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.server.connect())
def setup_client(self):
"""Set up client connection."""
self.agent_identity = Identity("name", address="client")
configuration = ConnectionConfig(
host="localost",
port="8888", # TODO: remove host/port for client?
connection_id=HTTPClientConnection.connection_id,
)
self.client = HTTPClientConnection(configuration=configuration,
identity=self.agent_identity)
self.client.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.client.connect())
def setup(self):
"""Set up test case."""
self.setup_server()
self.setup_client()
def _make_request(self,
path: str,
method: str = "get",
headers: str = "",
bodyy: bytes = b"") -> Envelope:
"""Make request envelope."""
request_http_message = HttpMessage(
dialogue_reference=("", ""),
target=0,
message_id=1,
performative=HttpMessage.Performative.REQUEST,
method=method,
url=f"http://{self.host}:{self.port}{path}",
headers="",
version="",
bodyy=b"",
)
request_envelope = Envelope(
to="receiver",
sender="sender",
protocol_id=HTTP_PROTOCOL_PUBLIC_ID,
message=request_http_message,
)
return request_envelope
def _make_response(self,
request_envelope: Envelope,
status_code: int = 200,
status_text: str = "") -> Envelope:
"""Make response envelope."""
incoming_message = cast(HttpMessage, request_envelope.message)
message = HttpMessage(
performative=HttpMessage.Performative.RESPONSE,
dialogue_reference=("", ""),
target=incoming_message.message_id,
message_id=incoming_message.message_id + 1,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=status_code,
status_text=status_text,
bodyy=incoming_message.bodyy,
)
response_envelope = Envelope(
to=request_envelope.sender,
sender=request_envelope.to,
protocol_id=request_envelope.protocol_id,
context=request_envelope.context,
message=message,
)
return response_envelope
@pytest.mark.asyncio
async def test_post_with_payload(self):
"""Test client and server with post request."""
initial_request = self._make_request("/test",
"POST",
bodyy=b"1234567890")
await self.client.send(initial_request)
request = await asyncio.wait_for(self.server.receive(), timeout=5)
initial_response = self._make_response(request)
await self.server.send(initial_response)
response = await asyncio.wait_for(self.client.receive(), timeout=5)
assert (cast(HttpMessage, initial_request.message).bodyy == cast(
HttpMessage, response.message).bodyy)
def teardown(self):
"""Tear down testcase."""
self.loop.run_until_complete(self.client.disconnect())
self.loop.run_until_complete(self.server.disconnect())
class TestClientServer:
"""Client-Server end-to-end test."""
def setup_server(self):
"""Set up server connection."""
self.server_agent_address = "server_agent_address"
self.server_agent_identity = Identity(
"agent running server", address=self.server_agent_address)
self.host = get_host()
self.port = get_unused_tcp_port()
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = HttpMessage.protocol_id
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=None, # do not filter on API spec
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.server = HTTPServerConnection(
configuration=self.configuration,
identity=self.server_agent_identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.server.connect())
# skill side dialogues
def role_from_first_message( # pylint: disable=unused-argument
message: Message,
receiver_address: Address) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return HttpDialogue.Role.SERVER
self._server_dialogues = HttpDialogues(
self.server_agent_address,
role_from_first_message=role_from_first_message)
def setup_client(self):
"""Set up client connection."""
self.client_agent_address = "client_agent_address"
self.client_agent_identity = Identity(
"agent running client", address=self.client_agent_address)
configuration = ConnectionConfig(
host="localost",
port="8888", # TODO: remove host/port for client?
connection_id=HTTPClientConnection.connection_id,
)
self.client = HTTPClientConnection(configuration=configuration,
identity=self.client_agent_identity)
self.loop.run_until_complete(self.client.connect())
# skill side dialogues
def role_from_first_message( # pylint: disable=unused-argument
message: Message,
receiver_address: Address) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return HttpDialogue.Role.CLIENT
self._client_dialogues = HttpDialogues(
self.client_agent_address,
role_from_first_message=role_from_first_message)
def setup(self):
"""Set up test case."""
self.setup_server()
self.setup_client()
def _make_request(self,
path: str,
method: str = "get",
headers: str = "",
body: bytes = b"") -> Envelope:
"""Make request envelope."""
request_http_message, _ = self._client_dialogues.create(
counterparty=str(HTTPClientConnection.connection_id),
performative=HttpMessage.Performative.REQUEST,
method=method,
url=f"http://{self.host}:{self.port}{path}",
headers="",
version="",
body=b"",
)
request_envelope = Envelope(
to=request_http_message.to,
sender=request_http_message.sender,
protocol_id=request_http_message.protocol_id,
message=request_http_message,
)
return request_envelope
def _make_response(self,
request_envelope: Envelope,
status_code: int = 200,
status_text: str = "") -> Envelope:
"""Make response envelope."""
incoming_message = cast(HttpMessage, request_envelope.message)
dialogue = self._server_dialogues.update(incoming_message)
assert dialogue is not None
message = dialogue.reply(
target_message=incoming_message,
performative=HttpMessage.Performative.RESPONSE,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=status_code,
status_text=status_text,
body=incoming_message.body,
)
response_envelope = Envelope(
to=message.to,
sender=message.sender,
protocol_id=message.protocol_id,
context=request_envelope.context,
message=message,
)
return response_envelope
@pytest.mark.asyncio
async def test_post_with_payload(self):
"""Test client and server with post request."""
initial_request = self._make_request("/test",
"POST",
body=b"1234567890")
await self.client.send(initial_request)
request = await asyncio.wait_for(self.server.receive(), timeout=5)
# this is "inside" the server agent
initial_response = self._make_response(request)
await self.server.send(initial_response)
response = await asyncio.wait_for(self.client.receive(), timeout=5)
assert (cast(HttpMessage, initial_request.message).body == cast(
HttpMessage, response.message).body)
assert (initial_request.message.dialogue_reference[0] ==
response.message.dialogue_reference[0])
@pytest.mark.asyncio
async def test_get_with_query(self):
"""Test client and server with url query."""
query = {"key": "value"}
path = "/test?{}".format(urllib.parse.urlencode(query))
initial_request = self._make_request(path, "GET")
await self.client.send(initial_request)
request = await asyncio.wait_for(self.server.receive(), timeout=5)
# this is "inside" the server agent
parsed_query = dict(
urllib.parse.parse_qsl(
urllib.parse.splitquery(
cast(HttpMessage, request.message).url)[1]))
assert parsed_query == query
initial_response = self._make_response(request)
await self.server.send(initial_response)
response = await asyncio.wait_for(self.client.receive(), timeout=5)
assert (initial_request.message.dialogue_reference[0] ==
response.message.dialogue_reference[0])
def teardown(self):
"""Tear down testcase."""
self.loop.run_until_complete(self.client.disconnect())
self.loop.run_until_complete(self.server.disconnect())