Exemple #1
0
    def on_message(self, msg_id: int, dialogue_id: int, origin: Address,
                   content: bytes) -> None:
        """
        On message event handler.

        :param msg_id: the message id.
        :param dialogue_id: the dialogue id.
        :param origin: the address of the sender.
        :param content: the bytes content.
        :return: None
        """
        # We are not using the 'msg_id', 'dialogue_id' and 'origin' parameters because 'content' contains a
        # serialized instance of 'Envelope', hence it already contains this information.
        self._check_loop_and_queue()
        envelope = Envelope.decode(content)
        asyncio.run_coroutine_threadsafe(self.in_queue.put(envelope),
                                         self.loop)
    def test_reception_c(self):
        """Test that the connection receives what has been enqueued in the input file."""
        encoded_envelope = b"0x5E22777dD831A459535AA4306AceC9cb22eC4cB5,default_oef,fetchai/oef_search:0.3.0,\x08\x02\x12\x011\x1a\x011 \x01:,\n*0x32468dB8Ab79549B49C88DC991990E7910891dbd,"
        expected_envelope = Envelope(
            to="0x5E22777dD831A459535AA4306AceC9cb22eC4cB5",
            sender="default_oef",
            protocol_id=PublicId.from_str("fetchai/oef_search:0.3.0"),
            message=
            b"\x08\x02\x12\x011\x1a\x011 \x01:,\n*0x32468dB8Ab79549B49C88DC991990E7910891dbd",
        )
        with open(self.input_file_path, "ab+") as f:
            with lock_file(f):
                f.write(encoded_envelope)
                f.flush()

        actual_envelope = self.multiplexer.get(block=True, timeout=3.0)
        assert expected_envelope == actual_envelope
Exemple #3
0
def test_inbox_get():
    """Tests for a envelope on the in queue."""
    msg = Message(content="hello")
    message_bytes = ProtobufSerializer().encode(msg)
    multiplexer = Multiplexer([_make_dummy_connection()])
    envelope = Envelope(
        to="Agent1",
        sender="Agent0",
        protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
        message=message_bytes,
    )
    multiplexer.in_queue.put(envelope)
    inbox = InBox(multiplexer)

    assert (
        inbox.get() == envelope
    ), "Checks if the returned envelope is the same with the queued envelope."
Exemple #4
0
    def send_unsupported_skill(self, envelope: Envelope, protocol: Protocol) -> None:
        """
        Handle the received envelope in case the skill is not supported.

        :param envelope: the envelope
        :param protocol: the protocol
        :return: None
        """
        logger.warning("Cannot handle envelope: no handler registered for the protocol '{}'.".format(protocol.id))
        encoded_envelope = base64.b85encode(envelope.encode()).decode("utf-8")
        reply = DefaultMessage(type=DefaultMessage.Type.ERROR,
                               error_code=DefaultMessage.ErrorCode.UNSUPPORTED_SKILL.value,
                               error_msg="Unsupported skill.",
                               error_data={"envelope": encoded_envelope})
        self.context.outbox.put_message(to=envelope.sender, sender=self.context.agent_public_key,
                                        protocol_id=DefaultMessage.protocol_id,
                                        message=DefaultSerializer().encode(reply))
Exemple #5
0
    def reset(self) -> None:
        """
        Reset the environment.

        :return: None
        """
        if not self._agent.multiplexer.is_connected:
            self._connect()
        gym_msg = GymMessage(performative=GymMessage.Performative.RESET)
        gym_bytes = GymSerializer().encode(gym_msg)
        envelope = Envelope(
            to=DEFAULT_GYM,
            sender=self._agent_address,
            protocol_id=GymMessage.protocol_id,
            message=gym_bytes,
        )
        self._agent.outbox.put(envelope)
Exemple #6
0
async def test_erc1155_get_state(erc1155_contract, ledger_apis_connection):
    """Test get state with contract erc1155."""
    address = ETHEREUM_ADDRESS_ONE
    contract_address = "0x250A2aeb3eB84782e83365b4c42dbE3CDA9920e4"
    contract_api_dialogues = ContractApiDialogues()
    token_id = 1
    request = ContractApiMessage(
        performative=ContractApiMessage.Performative.GET_STATE,
        dialogue_reference=contract_api_dialogues.
        new_self_initiated_dialogue_reference(),
        ledger_id=ETHEREUM,
        contract_id="fetchai/erc1155:0.6.0",
        contract_address=contract_address,
        callable="get_balance",
        kwargs=ContractApiMessage.Kwargs({
            "agent_address": address,
            "token_id": token_id
        }),
    )
    request.counterparty = str(ledger_apis_connection.connection_id)
    contract_api_dialogue = contract_api_dialogues.update(request)
    assert contract_api_dialogue is not None
    envelope = Envelope(
        to=str(ledger_apis_connection.connection_id),
        sender=address,
        protocol_id=request.protocol_id,
        message=request,
    )

    await ledger_apis_connection.send(envelope)
    await asyncio.sleep(0.01)
    response = await ledger_apis_connection.receive()

    assert response is not None
    assert type(response.message) == ContractApiMessage
    response_message = cast(ContractApiMessage, response.message)
    assert (response_message.performative ==
            ContractApiMessage.Performative.STATE), "Error: {}".format(
                response_message.message)
    response_dialogue = contract_api_dialogues.update(response_message)
    assert response_dialogue == contract_api_dialogue
    assert type(response_message.state) == State
    assert response_message.state.ledger_id == ETHEREUM
    result = response_message.state.body.get("balance", None)
    expected_result = {token_id: 0}
    assert result is not None and result == expected_result
def make_test_envelope() -> Envelope:
    """Create a test envelope."""
    msg = DefaultMessage(
        dialogue_reference=("", ""),
        message_id=1,
        target=0,
        performative=DefaultMessage.Performative.BYTES,
        content=b"hello",
    )
    msg.counterparty = "any"
    envelope = Envelope(
        to="any",
        sender="any",
        protocol_id=DefaultMessage.protocol_id,
        message=msg,
    )
    return envelope
async def test_erc1155_get_raw_message(erc1155_contract,
                                       ledger_apis_connection):
    """Test get state with contract erc1155."""
    address = ETHEREUM_ADDRESS_ONE
    contract_address = "0x250A2aeb3eB84782e83365b4c42dbE3CDA9920e4"
    contract_api_dialogues = ContractApiDialogues(address)
    request, contract_api_dialogue = contract_api_dialogues.create(
        counterparty=str(ledger_apis_connection.connection_id),
        performative=ContractApiMessage.Performative.GET_RAW_MESSAGE,
        ledger_id=ETHEREUM,
        contract_id=str(ERC1155_PUBLIC_ID),
        contract_address=contract_address,
        callable="get_hash_single",
        kwargs=ContractApiMessage.Kwargs({
            "from_address": address,
            "to_address": address,
            "token_id": 1,
            "from_supply": 10,
            "to_supply": 0,
            "value": 0,
            "trade_nonce": 1,
        }),
    )
    envelope = Envelope(
        to=request.to,
        sender=request.sender,
        protocol_id=request.protocol_id,
        message=request,
    )

    await ledger_apis_connection.send(envelope)
    await asyncio.sleep(0.01)
    response = await ledger_apis_connection.receive()

    assert response is not None
    assert type(response.message) == ContractApiMessage
    response_message = cast(ContractApiMessage, response.message)
    assert (response_message.performative ==
            ContractApiMessage.Performative.RAW_MESSAGE), "Error: {}".format(
                response_message.message)
    response_dialogue = contract_api_dialogues.update(response_message)
    assert response_dialogue == contract_api_dialogue
    assert type(response_message.raw_message) == RawMessage
    assert response_message.raw_message.ledger_id == ETHEREUM
    assert type(response.message.raw_message.body) == bytes
Exemple #9
0
def test_storage_access_from_handler():
    """Test storage access from handler component."""
    builder = AEABuilder()
    builder.set_name("aea_1")
    builder.add_private_key(DEFAULT_LEDGER)

    skill_context = SkillContext()
    handler = THandler(name="behaviour", skill_context=skill_context)
    test_skill = Skill(
        SkillConfig(name="test_skill", author="fetchai"),
        skill_context=skill_context,
        handlers={"handler": handler},
        behaviours={},
    )

    builder.add_component_instance(test_skill)
    builder.set_storage_uri("sqlite://:memory:")
    aea = builder.build()
    skill_context.set_agent_context(aea.context)

    aea.runtime._threaded = True
    aea.runtime.start()

    msg = DefaultMessage(
        dialogue_reference=("", ""),
        message_id=1,
        target=0,
        performative=DefaultMessage.Performative.BYTES,
        content=b"hello",
    )
    msg.to = aea.identity.address
    msg.sender = aea.identity.address
    envelope = Envelope(to=msg.to, sender=msg.sender, message=msg,)
    try:
        wait_for_condition(lambda: aea.is_running, timeout=10)

        aea.runtime.multiplexer.in_queue.put(envelope)

        wait_for_condition(lambda: handler.counter > 0, timeout=10)

        col = skill_context.storage.get_sync_collection(handler.COL_NAME)
        assert col.get(handler.OBJ_ID) == handler.OBJ_BODY
    finally:
        aea.runtime.stop()
        aea.runtime.wait_completed(sync=True, timeout=10)
Exemple #10
0
        def test_search_services_with_distance_query(self):
            """Test that a search services request can be sent correctly.

            In this test, the query has a simple data model.
            """
            tour_eiffel = Location(48.8581064, 2.29447)
            attribute = Attribute("latlon", Location, True)
            data_model = DataModel("geolocation", [attribute])
            search_query = Query(
                [
                    Constraint(attribute.name,
                               ConstraintType("distance", (tour_eiffel, 1.0)))
                ],
                model=data_model,
            )
            oef_search_request = OefSearchMessage(
                performative=OefSearchMessage.Performative.SEARCH_SERVICES,
                dialogue_reference=self.oef_search_dialogues.
                new_self_initiated_dialogue_reference(),
                query=search_query,
            )
            oef_search_request.counterparty = str(
                self.connection.connection_id)
            sending_dialogue = self.oef_search_dialogues.update(
                oef_search_request)
            assert sending_dialogue is not None
            self.multiplexer.put(
                Envelope(
                    to=str(self.connection.connection_id),
                    sender=FETCHAI_ADDRESS_ONE,
                    protocol_id=OefSearchMessage.protocol_id,
                    message=oef_search_request,
                ))
            envelope = self.multiplexer.get(block=True, timeout=5.0)
            oef_search_response_original = envelope.message
            oef_search_response = copy.copy(oef_search_response_original)
            oef_search_response.is_incoming = True
            oef_search_response.counterparty = oef_search_response_original.sender
            oef_search_dialogue = self.oef_search_dialogues.update(
                oef_search_response)
            assert (oef_search_response.performative ==
                    OefSearchMessage.Performative.SEARCH_RESULT)
            assert oef_search_dialogue is not None
            assert oef_search_dialogue == sending_dialogue
            assert oef_search_response.agents == ()
Exemple #11
0
async def test_erc1155_get_raw_transaction(erc1155_contract,
                                           ledger_apis_connection):
    """Test get state with contract erc1155."""
    address = ETHEREUM_ADDRESS_ONE
    contract_address = "0x250A2aeb3eB84782e83365b4c42dbE3CDA9920e4"
    contract_api_dialogues = ContractApiDialogues()
    request = ContractApiMessage(
        performative=ContractApiMessage.Performative.GET_RAW_TRANSACTION,
        dialogue_reference=contract_api_dialogues.
        new_self_initiated_dialogue_reference(),
        ledger_id=ETHEREUM,
        contract_id="fetchai/erc1155:0.6.0",
        contract_address=contract_address,
        callable="get_create_batch_transaction",
        kwargs=ContractApiMessage.Kwargs({
            "deployer_address":
            address,
            "token_ids": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        }),
    )
    request.counterparty = str(ledger_apis_connection.connection_id)
    contract_api_dialogue = contract_api_dialogues.update(request)
    assert contract_api_dialogue is not None
    envelope = Envelope(
        to=str(ledger_apis_connection.connection_id),
        sender=address,
        protocol_id=request.protocol_id,
        message=request,
    )

    await ledger_apis_connection.send(envelope)
    await asyncio.sleep(0.01)
    response = await ledger_apis_connection.receive()

    assert response is not None
    assert type(response.message) == ContractApiMessage
    response_message = cast(ContractApiMessage, response.message)
    assert (response_message.performative == ContractApiMessage.Performative.
            RAW_TRANSACTION), "Error: {}".format(response_message.message)
    response_dialogue = contract_api_dialogues.update(response_message)
    assert response_dialogue == contract_api_dialogue
    assert type(response_message.raw_transaction) == RawTransaction
    assert response_message.raw_transaction.ledger_id == ETHEREUM
    assert len(response.message.raw_transaction.body) == 7
    assert len(response.message.raw_transaction.body["data"]) > 0
Exemple #12
0
    async def test_channel_cancel_tasks_on_disconnect(self):
        """Test requests tasks cancelled on disconnect."""
        await self.http_client_connection.connect()
        request_http_message, _ = self.http_dialogs.create(
            counterparty=self.connection_address,
            performative=HttpMessage.Performative.REQUEST,
            method="get",
            url="https://not-a-google.com",
            headers="",
            version="",
            body=b"",
        )
        request_envelope = Envelope(
            to=self.connection_address,
            sender=self.agent_address,
            protocol_specification_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
            message=request_http_message,
        )

        connection_response_mock = Mock()
        connection_response_mock.status_code = 200

        response_mock = Mock()
        response_mock.status = 200
        response_mock.headers = {"headers": "some header"}
        response_mock.reason = "OK"
        response_mock._body = b"Some content"
        response_mock.read.return_value = asyncio.Future()

        with patch.object(
                aiohttp.ClientSession,
                "request",
                return_value=_MockRequest(response_mock),
        ):
            await self.http_client_connection.send(envelope=request_envelope)

            assert self.http_client_connection.channel._tasks
            task = list(self.http_client_connection.channel._tasks)[0]
            assert not task.done()
        await self.http_client_connection.disconnect()

        assert not self.http_client_connection.channel._tasks
        assert task.done()
        with pytest.raises(CancelledError):
            await task
Exemple #13
0
    async def _generic_command_handler(
        self,
        service_description: Description,
        oef_message: OefSearchMessage,
        oef_search_dialogue: OefSearchDialogue,
    ) -> None:
        """
        Perform ping command.

        :param service_description: Service description

        :return None
        """
        if not self.in_queue:  # pragma: no cover
            """not connected."""
            return

        self._check_data_model(service_description,
                               ModelNames.GENERIC_COMMAND.value)
        command = service_description.values.get("command", None)
        params = service_description.values.get("parameters", {})

        if params:
            params = urllib.parse.parse_qs(params)

        content = await self._generic_oef_command(command, params)

        message = oef_search_dialogue.reply(
            performative=OefSearchMessage.Performative.SUCCESS,
            target_message=oef_message,
            agents_info=AgentsInfo({
                "response": {
                    "content": content
                },
                "command": service_description.values,
            }),
        )
        envelope = Envelope(
            to=message.to,
            sender=message.sender,
            protocol_id=message.protocol_id,
            message=message,
            context=oef_search_dialogue.envelope_context,
        )
        await self.in_queue.put(envelope)
async def test_p2p_send():
    """Test the send functionality of the p2p connection."""
    address = "127.0.0.1"
    port = 8000
    m_fet_key = "6d56fd47e98465824aa85dfe620ad3dbf092b772abc6c6a182e458b5c56ad13b"
    ent = entity.Entity.from_hex(m_fet_key)
    p2p_client_connection = _make_p2p_client_connection(
        address=ent.public_key_hex, provider_addr=address, provider_port=port,
    )
    p2p_client_connection.loop = asyncio.get_event_loop()
    envelope = Envelope(
        to="receiver",
        sender="sender",
        protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
        message=b"Hello",
    )

    with mock.patch.object(
        fetch.p2p.api.http_calls.HTTPCalls, "get_messages", return_value=[]
    ):
        with mock.patch.object(
            fetch.p2p.api.http_calls.HTTPCalls,
            "register",
            return_value={"status": "OK"},
        ):
            await p2p_client_connection.connect()
            assert p2p_client_connection.connection_status.is_connected is True

    with mock.patch.object(
        fetch.p2p.api.http_calls.HTTPCalls, "get_messages", return_value=[]
    ):
        with mock.patch.object(
            fetch.p2p.api.http_calls.HTTPCalls,
            "send_message",
            return_value={"status": "OK"},
        ):
            await p2p_client_connection.send(envelope=envelope)
            # TODO: Consider returning the response from the server in order to be able to assert that the message send!
            assert True

    with mock.patch.object(
        fetch.p2p.api.http_calls.HTTPCalls, "unregister", return_value={"status": "OK"},
    ):
        await p2p_client_connection.disconnect()
        assert p2p_client_connection.connection_status.is_connected is False
Exemple #15
0
    def test_echo(self):
        """Run the echo skill sequence."""
        self.add_item("skill", "fetchai/echo:0.3.0")

        process = self.run_agent()
        is_running = self.is_running(process)
        assert is_running, "AEA not running within timeout!"

        # add sending and receiving envelope from input/output files
        message_content = b"hello"
        message = DefaultMessage(
            performative=DefaultMessage.Performative.BYTES,
            content=message_content,
        )
        sent_envelope = Envelope(
            to=self.agent_name,
            sender="sender",
            protocol_id=message.protocol_id,
            message=message,
        )

        self.send_envelope_to_agent(sent_envelope, self.agent_name)

        time.sleep(2.0)
        received_envelope = self.read_envelope_from_agent(self.agent_name)

        # assert sent_envelope.to == received_envelope.sender
        assert sent_envelope.sender == received_envelope.to
        assert sent_envelope.protocol_id == received_envelope.protocol_id
        msg = DefaultMessage.serializer.decode(received_envelope.message)
        assert sent_envelope.message == msg

        check_strings = (
            "Echo Handler: setup method called.",
            "Echo Behaviour: setup method called.",
            "Echo Behaviour: act method called.",
            "content={}".format(message_content),
        )
        missing_strings = self.missing_from_output(process, check_strings)
        assert (
            missing_strings == []
        ), "Strings {} didn't appear in agent output.".format(missing_strings)

        assert (self.is_successfully_terminated()
                ), "Echo agent wasn't successfully terminated."
Exemple #16
0
def test_inbox_nowait():
    """Tests the inbox without waiting."""
    agent_address = "Agent0"
    receiver_address = "Agent1"
    msg = Message(content="hello")
    msg.counterparty = receiver_address
    multiplexer = Multiplexer([_make_dummy_connection()])
    envelope = Envelope(
        to=receiver_address,
        sender=agent_address,
        protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID,
        message=msg,
    )
    multiplexer.in_queue.put(envelope)
    inbox = InBox(multiplexer)
    assert (
        inbox.get_nowait() == envelope
    ), "Check for a message on the in queue and wait for no time."
Exemple #17
0
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."
        )
Exemple #18
0
    async def send_add_metric(self, title: str, metric_type: str) -> None:
        """Send an add_metric message."""
        msg, sending_dialogue = self.dialogues.create(
            counterparty=self.prometheus_address,
            performative=PrometheusMessage.Performative.ADD_METRIC,
            title=title,
            type=metric_type,
            description="a gauge",
            labels={},
        )
        assert sending_dialogue is not None

        envelope = Envelope(
            to=msg.to,
            sender=msg.sender,
            message=msg,
        )
        await self.prometheus_con.send(envelope)
Exemple #19
0
    async def test_send_connection_error(self):
        """Test send connection error."""
        msg = GymMessage(
            performative=GymMessage.Performative.ACT,
            action=GymMessage.AnyObject("any_action"),
            step_id=1,
        )
        msg_bytes = GymSerializer().encode(msg)
        envelope = Envelope(
            to="_to_key",
            sender="_from_key",
            protocol_id=GymMessage.protocol_id,
            message=msg_bytes,
        )

        self.gym_con.connection_status.is_connected = False
        with pytest.raises(ConnectionError):
            await self.gym_con.send(envelope)
Exemple #20
0
    def on_search_result(self, search_id: int, agents: List[str]) -> None:
        """
        On accept event handler.

        :param search_id: the search id.
        :param agents: the list of agents.
        :return: None
        """
        self.mail_stats.search_end(search_id, len(agents))
        msg = OEFMessage(oef_type=OEFMessage.Type.SEARCH_RESULT,
                         id=search_id,
                         agents=agents)
        msg_bytes = OEFSerializer().encode(msg)
        envelope = Envelope(to=self.public_key,
                            sender=DEFAULT_OEF,
                            protocol_id=OEFMessage.protocol_id,
                            message=msg_bytes)
        self.in_queue.put(envelope)
Exemple #21
0
async def test_send_envelope_with_non_registered_connection():
    """Test that sending an envelope with an unregistered connection raises an exception."""
    connection = _make_dummy_connection()
    multiplexer = Multiplexer([connection])
    multiplexer.connect()

    envelope = Envelope(
        to="",
        sender="",
        protocol_id=DefaultMessage.protocol_id,
        message=b"",
        context=EnvelopeContext(connection_id=UNKNOWN_CONNECTION_PUBLIC_ID),
    )

    with pytest.raises(AEAConnectionError, match="No connection registered with id:.*"):
        await multiplexer._send(envelope)

    multiplexer.disconnect()
Exemple #22
0
def _decode(e: bytes, separator: bytes = SEPARATOR):
    split = e.split(separator)

    if len(split) < 5 or split[-1] not in [b"", b"\n"]:
        raise ValueError(
            "Expected at least 5 values separated by commas and last value being empty or new line, got {}".format(
                len(split)
            )
        )

    to = split[0].decode("utf-8").strip()
    sender = split[1].decode("utf-8").strip()
    protocol_id = PublicId.from_str(split[2].decode("utf-8").strip())
    # protobuf messages cannot be delimited as they can contain an arbitrary byte sequence; however
    # we know everything remaining constitutes the protobuf message.
    message = SEPARATOR.join(split[3:-1])

    return Envelope(to=to, sender=sender, protocol_id=protocol_id, message=message)
Exemple #23
0
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."
        )
Exemple #24
0
 def test_send_message(self):
     """Test that a default byte message can be sent correctly."""
     msg = DefaultMessage(
         dialogue_reference=("", ""),
         message_id=1,
         target=0,
         performative=DefaultMessage.Performative.BYTES,
         content=b"hello",
     )
     self.multiplexer.put(
         Envelope(
             to=FETCHAI_ADDRESS_ONE,
             sender=FETCHAI_ADDRESS_ONE,
             protocol_id=DefaultMessage.protocol_id,
             message=msg,
         ))
     recv_msg = self.multiplexer.get(block=True, timeout=3.0)
     assert recv_msg is not None
Exemple #25
0
 async def test_bad_performative(self, caplog):
     """Test fail on bad perfromative."""
     agent_location = Location(52.2057092, 2.1183431)
     service_instance = {"location": agent_location}
     service_description = Description(
         service_instance, data_model=models.AGENT_LOCATION_MODEL
     )
     message = OefSearchMessage(
         performative="oef_error", service_description=service_description,
     )
     envelope = Envelope(
         to="soef",
         sender=self.crypto.address,
         protocol_id=message.protocol_id,
         message=message,
     )
     with pytest.raises(ValueError):
         await self.connection.send(envelope)
Exemple #26
0
async def test_callable_wrong_number_of_arguments_apis(
    erc1155_contract, ledger_apis_connection
):
    """
    Test a contract callable with wrong number of arguments.

    Test the case of either GET_DEPLOY_TRANSACTION.
    """
    contract, contract_address = erc1155_contract
    address = ETHEREUM_ADDRESS_ONE
    contract_api_dialogues = ContractApiDialogues(address)
    request, _ = contract_api_dialogues.create(
        counterparty=str(ledger_apis_connection.connection_id),
        performative=ContractApiMessage.Performative.GET_DEPLOY_TRANSACTION,
        ledger_id=ETHEREUM,
        contract_id=str(ERC1155_PUBLIC_ID),
        callable="get_deploy_transaction",
        kwargs=ContractApiMessage.Kwargs({}),
    )
    envelope = Envelope(to=request.to, sender=request.sender, message=request,)

    with unittest.mock.patch(
        "inspect.getfullargspec", return_value=unittest.mock.MagicMock(args=[])
    ):
        with unittest.mock.patch.object(
            ledger_apis_connection._contract_dispatcher, "_call_stub", return_value=None
        ):
            with unittest.mock.patch.object(
                ledger_apis_connection._contract_dispatcher.logger, "error"
            ) as mock_logger:
                await ledger_apis_connection.send(envelope)
                await asyncio.sleep(0.01)
                response = await ledger_apis_connection.receive()
                mock_logger.assert_any_call(
                    "Exception during contract request: Expected one or more positional arguments, got 0"
                )
                assert (
                    response.message.performative
                    == ContractApiMessage.Performative.ERROR
                )
                assert (
                    response.message.message
                    == "Expected one or more positional arguments, got 0"
                )
    def test_communication_direct(self):
        for uri in PUBLIC_DHT_DELEGATE_URIS:
            connection1 = _make_libp2p_client_connection(uri=uri)
            multiplexer1 = Multiplexer([connection1])
            multiplexer1.connect()

            connection2 = _make_libp2p_client_connection(uri=uri)
            multiplexer2 = Multiplexer([connection2])
            multiplexer2.connect()

            addr_1 = connection1.address
            addr_2 = connection2.address

            msg = DefaultMessage(
                dialogue_reference=("", ""),
                message_id=1,
                target=0,
                performative=DefaultMessage.Performative.BYTES,
                content=b"hello",
            )
            envelope = Envelope(
                to=addr_2,
                sender=addr_1,
                protocol_id=DefaultMessage.protocol_id,
                message=msg,
            )

            multiplexer1.put(envelope)
            delivered_envelope = multiplexer2.get(block=True, timeout=20)

            try:
                assert delivered_envelope is not None
                assert delivered_envelope.to == envelope.to
                assert delivered_envelope.sender == envelope.sender
                assert delivered_envelope.protocol_id == envelope.protocol_id
                assert delivered_envelope.message != envelope.message
                msg = DefaultMessage.serializer.decode(
                    delivered_envelope.message)
                assert envelope.message == msg
            except Exception:
                raise
            finally:
                multiplexer1.disconnect()
                multiplexer2.disconnect()
Exemple #28
0
    def to_envelope(
        self,
        connection_id: PublicId,
        http_request_message: HttpMessage,
        status_code: int,
        headers: dict,
        status_text: Optional[Any],
        bodyy: bytes,
        dialogue: HttpDialogue,
    ) -> Envelope:
        """
        Convert an HTTP response object (from the 'requests' library) into an Envelope containing an HttpMessage (from the 'http' Protocol).

        :param connection_id: the connection id
        :param http_request_message: the message of the http request envelop
        :param status_code: the http status code, int
        :param headers: dict of http response headers
        :param status_text: the http status_text, str
        :param bodyy: bytes of http response content

        :return: Envelope with http response data.
        """
        context = EnvelopeContext(connection_id=connection_id)
        http_message = HttpMessage(
            performative=HttpMessage.Performative.RESPONSE,
            status_code=status_code,
            headers=json.dumps(dict(headers.items())),
            status_text=status_text,
            bodyy=bodyy,
            version="",
            dialogue_reference=dialogue.dialogue_label.dialogue_reference,
            target=http_request_message.message_id,
            message_id=http_request_message.message_id + 1,
        )
        http_message.counterparty = http_request_message.counterparty
        assert dialogue.update(http_message)
        envelope = Envelope(
            to=self.agent_address,
            sender="HTTP Server",
            protocol_id=PublicId.from_str("fetchai/http:0.4.0"),
            context=context,
            message=http_message,
        )
        return envelope
async def test_callable_wrong_number_of_arguments_api_and_contract_address(
        erc1155_contract, ledger_apis_connection):
    """
    Test a contract callable with wrong number of arguments.

    Test the case of either GET_STATE, GET_RAW_MESSAGE or GET_RAW_TRANSACTION.
    """
    address = ETHEREUM_ADDRESS_ONE
    contract_api_dialogues = ContractApiDialogues(address)
    token_id = 1
    contract_address = "0x250A2aeb3eB84782e83365b4c42dbE3CDA9920e4"
    request, _ = contract_api_dialogues.create(
        counterparty=str(ledger_apis_connection.connection_id),
        performative=ContractApiMessage.Performative.GET_STATE,
        ledger_id=ETHEREUM,
        contract_id=str(ERC1155_PUBLIC_ID),
        contract_address=contract_address,
        callable="get_balance",
        kwargs=ContractApiMessage.Kwargs({
            "agent_address": address,
            "token_id": token_id
        }),
    )
    envelope = Envelope(
        to=request.to,
        sender=request.sender,
        protocol_id=request.protocol_id,
        message=request,
    )

    with unittest.mock.patch(
            "inspect.getfullargspec",
            return_value=unittest.mock.MagicMock(args=[None])):
        with unittest.mock.patch.object(ledger_apis_connection._logger,
                                        "error") as mock_logger:
            await ledger_apis_connection.send(envelope)
            await asyncio.sleep(0.01)
            response = await ledger_apis_connection.receive()
            mock_logger.assert_any_call(
                "Expected two or more positional arguments, got 1")
            assert (response.message.performative ==
                    ContractApiMessage.Performative.ERROR)
            assert (response.message.message ==
                    "Expected two or more positional arguments, got 1")
Exemple #30
0
 def register_personality_pieces(self,
                                 piece: str = "genus",
                                 value: str = "service") -> None:
     """Register personality pieces."""
     service_instance = {"piece": piece, "value": value}
     service_description = Description(
         service_instance, data_model=models.AGENT_PERSONALITY_MODEL)
     message, _ = self.oef_search_dialogues.create(
         counterparty=str(SOEFConnection.connection_id.to_any()),
         performative=OefSearchMessage.Performative.REGISTER_SERVICE,
         service_description=service_description,
     )
     envelope = Envelope(
         to=message.to,
         sender=message.sender,
         message=message,
     )
     logger.info("Registering agent personality")
     self.multiplexer.put(envelope)