Merge branch 'main' into test/acpClient

Author: JohnsonChin1009

.gitignore

@@ -21,3 +21,6 @@ __pycache__/
 
 # Intellij IDEA files
 .idea/
+tests/.env
+htmlcov/
+.coverage

examples/acp_base/skip_evaluation/buyer.py

@@ -87,7 +87,7 @@ def on_new_task(job: ACPJob, memo_to_sign: Optional[ACPMemo] = None):
             "<your-schema-key-1>": "<your-schema-value-1>",
             "<your-schema-key-2>": "<your-schema-value-2>",
         },
-        expired_at=datetime.now() + timedelta(minutes=3.1),  # job expiry duration, minimum 3 minutes
+        expired_at=datetime.now() + timedelta(minutes=5),  # job expiry duration, minimum 3 minutes
     )
     logger.info(f"Job {job_id} initiated")
     logger.info("Listening for next steps...")

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "virtuals-acp"
-version = "0.3.16"
+version = "0.3.18"
 description = "Agent Commerce Protocol Python SDK by Virtuals"
 authors = ["Steven Lee Soon Fatt <steven@virtuals.io>"]
 readme = "README.md"

tests/.env.example

@@ -0,0 +1,11 @@
+# General Variables
+WHITELISTED_WALLET_ADDRESS=<YOUR_WHITELISTED_WALLET_ADDRESS>
+WHITELISTED_WALLET_PRIVATE_KEY=<YOUR_WHITELISTED_PRIVATE_KEY>
+
+# Seller Agent Variables
+SELLER_ENTITY_ID=<YOUR_SELLER_ENTITY_ID>
+SELLER_AGENT_WALLET_ADDRESS=<YOUR_SELLER_AGENT_WALLET_ADDRESS>
+
+# Buyer Agent Variables
+BUYER_ENTITY_ID=<YOUR_BUYER_ENTITY_ID>
+BUYER_AGENT_WALLET_ADDRESS=<YOUR_BUYER_AGENT_WALLET_ADDRESS>

tests/conftest.py

@@ -3,6 +3,7 @@
 import pytest
 
 
+# Load .env file from tests directory if it exists
 def pytest_configure(config):
     """Load environment variables from tests/.env before running tests"""
     env_file = Path(__file__).parent / ".env"

tests/integration/test_integration_contract_client_v2.py

@@ -0,0 +1,57 @@
+import pytest
+import os
+from virtuals_acp.contract_clients.contract_client_v2 import ACPContractClientV2
+
+
+# Skip all integration tests if environment variables are not set
+pytestmark = pytest.mark.integration
+
+# Check if we have required environment variables for integration tests
+SKIP_INTEGRATION = not all([
+    os.getenv("WHITELISTED_WALLET_PRIVATE_KEY"),
+    os.getenv("SELLER_AGENT_WALLET_ADDRESS"),
+    os.getenv("SELLER_ENTITY_ID"),
+])
+
+
+@pytest.mark.skipif(SKIP_INTEGRATION, reason="Integration test environment variables not set")
+class TestIntegrationACPContractClientV2:
+    @pytest.fixture(scope="class")
+    def integration_client(self):
+        wallet_private_key = os.getenv("WHITELISTED_WALLET_PRIVATE_KEY")
+        agent_wallet_address = os.getenv("SELLER_AGENT_WALLET_ADDRESS")
+        entity_id = int(os.getenv("SELLER_ENTITY_ID", "0"))
+
+        try:
+            client = ACPContractClientV2(
+                agent_wallet_address=agent_wallet_address,
+                wallet_private_key=wallet_private_key,
+                entity_id=entity_id,
+            )
+            yield client
+        except Exception as e:
+            pytest.fail(f"Failed to initialize integration client: {e}")
+
+    class TestInitialization:
+        def test_should_connect_to_mainnet(self, integration_client):
+            assert integration_client is not None
+            assert integration_client.agent_wallet_address is not None
+
+        def test_should_have_valid_web3_connection(self, integration_client):
+            assert integration_client.w3 is not None
+            assert integration_client.w3.is_connected()
+
+        def test_should_fetch_manager_addresses(self, integration_client):
+            assert integration_client.job_manager_address is not None
+            assert integration_client.job_manager_address.startswith("0x")
+
+        def test_should_validate_session_key(self, integration_client):
+            # If client initialized, session key validation already passed
+            assert integration_client.account is not None
+            assert integration_client.entity_id is not None
+
+        def test_should_have_x402_instance(self, integration_client):
+            assert integration_client.x402 is not None
+
+        def test_should_have_alchemy_kit_instance(self, integration_client):
+            assert integration_client.alchemy_kit is not None

tests/unit/test_account.py

@@ -0,0 +1,203 @@
+import pytest
+import json
+from unittest.mock import MagicMock
+from virtuals_acp.account import ACPAccount
+from virtuals_acp.models import OperationPayload
+
+TEST_AGENT_ADDRESS = "0x1234567890123456789012345678901234567890"
+TEST_PROVIDER_ADDRESS = "0x5555555555555555555555555555555555555555"
+
+
+class TestACPAccount:
+    @pytest.fixture
+    def mock_contract_client(self):
+        """Create a mock contract client"""
+        return MagicMock()
+
+    @pytest.fixture
+    def sample_metadata(self):
+        """Sample metadata for testing"""
+        return {
+            "service_name": "AI Trading Bot",
+            "category": "trading",
+            "tags": ["ai", "trading", "defi"]
+        }
+
+    @pytest.fixture
+    def account(self, mock_contract_client, sample_metadata):
+        """Create an ACPAccount instance for testing"""
+        return ACPAccount(
+            contract_client=mock_contract_client,
+            id=123,
+            client_address=TEST_AGENT_ADDRESS,
+            provider_address=TEST_PROVIDER_ADDRESS,
+            metadata=sample_metadata
+        )
+
+    class TestInitialization:
+        """Test account initialization"""
+
+        def test_should_initialize_with_all_parameters(
+            self, mock_contract_client, sample_metadata
+        ):
+            """Should correctly initialize account with all parameters"""
+            account = ACPAccount(
+                contract_client=mock_contract_client,
+                id=456,
+                client_address=TEST_AGENT_ADDRESS,
+                provider_address=TEST_PROVIDER_ADDRESS,
+                metadata=sample_metadata
+            )
+
+            assert account.contract_client == mock_contract_client
+            assert account.id == 456
+            assert account.client_address == TEST_AGENT_ADDRESS
+            assert account.provider_address == TEST_PROVIDER_ADDRESS
+            assert account.metadata == sample_metadata
+
+        def test_should_initialize_with_empty_metadata(self, mock_contract_client):
+            """Should initialize with empty metadata dictionary"""
+            account = ACPAccount(
+                contract_client=mock_contract_client,
+                id=789,
+                client_address=TEST_AGENT_ADDRESS,
+                provider_address=TEST_PROVIDER_ADDRESS,
+                metadata={}
+            )
+
+            assert account.metadata == {}
+
+        def test_should_store_metadata_reference(self, mock_contract_client):
+            """Should store reference to metadata dictionary"""
+            metadata = {"key": "value"}
+            account = ACPAccount(
+                contract_client=mock_contract_client,
+                id=111,
+                client_address=TEST_AGENT_ADDRESS,
+                provider_address=TEST_PROVIDER_ADDRESS,
+                metadata=metadata
+            )
+
+            assert account.metadata == {"key": "value"}
+
+    class TestUpdateMetadata:
+        """Test update_metadata method"""
+
+        def test_should_call_contract_client_with_json_string(
+            self, account, mock_contract_client
+        ):
+            """Should call contract client's update_account_metadata with JSON string"""
+            new_metadata = {"updated": "data", "version": 2}
+            mock_operation = MagicMock(spec=OperationPayload)
+            mock_contract_client.update_account_metadata.return_value = mock_operation
+
+            result = account.update_metadata(new_metadata)
+
+            # Verify contract client was called with correct parameters
+            mock_contract_client.update_account_metadata.assert_called_once_with(
+                123,  # account.id
+                json.dumps(new_metadata)
+            )
+
+            # Verify operation payload was returned
+            assert result == mock_operation
+
+        def test_should_serialize_complex_metadata_to_json(
+            self, account, mock_contract_client
+        ):
+            """Should properly serialize complex metadata structures to JSON"""
+            complex_metadata = {
+                "name": "Test Service",
+                "tags": ["tag1", "tag2"],
+                "config": {
+                    "nested": {
+                        "value": 123,
+                        "enabled": True
+                    }
+                }
+            }
+            mock_contract_client.update_account_metadata.return_value = MagicMock()
+
+            account.update_metadata(complex_metadata)
+
+            # Verify the JSON string is properly formatted
+            call_args = mock_contract_client.update_account_metadata.call_args[0]
+            assert call_args[0] == 123
+            assert call_args[1] == json.dumps(complex_metadata)
+
+            # Verify JSON is valid by parsing it back
+            parsed = json.loads(call_args[1])
+            assert parsed == complex_metadata
+
+        def test_should_handle_empty_metadata_update(
+            self, account, mock_contract_client
+        ):
+            """Should handle updating with empty metadata"""
+            mock_contract_client.update_account_metadata.return_value = MagicMock()
+
+            account.update_metadata({})
+
+            mock_contract_client.update_account_metadata.assert_called_once_with(
+                123,
+                "{}"
+            )
+
+        def test_should_update_different_account_ids(self, mock_contract_client):
+            """Should use correct account ID for different accounts"""
+            account1 = ACPAccount(
+                contract_client=mock_contract_client,
+                id=111,
+                client_address=TEST_AGENT_ADDRESS,
+                provider_address=TEST_PROVIDER_ADDRESS,
+                metadata={}
+            )
+            account2 = ACPAccount(
+                contract_client=mock_contract_client,
+                id=222,
+                client_address=TEST_AGENT_ADDRESS,
+                provider_address=TEST_PROVIDER_ADDRESS,
+                metadata={}
+            )
+
+            mock_contract_client.update_account_metadata.return_value = MagicMock()
+
+            account1.update_metadata({"account": 1})
+            account2.update_metadata({"account": 2})
+
+            # Verify first call used account1's ID
+            first_call = mock_contract_client.update_account_metadata.call_args_list[0]
+            assert first_call[0][0] == 111
+
+            # Verify second call used account2's ID
+            second_call = mock_contract_client.update_account_metadata.call_args_list[1]
+            assert second_call[0][0] == 222
+
+        def test_should_not_modify_original_metadata_property(
+            self, account, mock_contract_client
+        ):
+            """Should not modify the account's metadata property when updating"""
+            original_metadata = account.metadata.copy()
+            mock_contract_client.update_account_metadata.return_value = MagicMock()
+
+            new_metadata = {"completely": "different"}
+            account.update_metadata(new_metadata)
+
+            # Original metadata should remain unchanged
+            assert account.metadata == original_metadata
+
+        def test_should_return_operation_payload_from_contract_client(
+            self, account, mock_contract_client
+        ):
+            """Should return the operation payload from contract client"""
+            mock_operation = MagicMock(spec=OperationPayload)
+            mock_operation.target = "0xContractAddress"
+            mock_operation.data = "0xEncodedData"
+            mock_operation.value = 0
+
+            mock_contract_client.update_account_metadata.return_value = mock_operation
+
+            result = account.update_metadata({"test": "data"})
+
+            assert result is mock_operation
+            assert result.target == "0xContractAddress"
+            assert result.data == "0xEncodedData"