fix: unit test & use get_balances from alephHttpClient instead of hardcoded one

Author: 1yam

src/aleph_client/commands/account.py

@@ -9,7 +9,7 @@
 
 import aiohttp
 import typer
-from aleph.sdk import AuthenticatedAlephHttpClient, AlephHttpClient
+from aleph.sdk import AlephHttpClient, AuthenticatedAlephHttpClient
 from aleph.sdk.account import _load_account
 from aleph.sdk.chains.common import generate_key
 from aleph.sdk.chains.solana import parse_private_key as parse_solana_private_key
@@ -303,14 +303,16 @@ async def balance(
 
     if address:
         try:
-            balance_data = await get_balance(address)
+            async with AlephHttpClient() as client:
+                balance_data = await client.get_balances(address)
+                available = balance_data.balance - balance_data.locked_amount
             infos = [
-                Text.from_markup(f"Address: [bright_cyan]{balance_data['address']}[/bright_cyan]"),
+                Text.from_markup(f"Address: [bright_cyan]{balance_data.address}[/bright_cyan]"),
                 Text.from_markup(
-                    f"\nBalance: [bright_cyan]{displayable_amount(balance_data['balance'], decimals=2)}[/bright_cyan]"
+                    f"\nBalance: [bright_cyan]{displayable_amount(balance_data.balance, decimals=2)}[/bright_cyan]"
                 ),
             ]
-            details = balance_data.get("details")
+            details = balance_data.details
             if details:
                 infos += [Text("\n ↳ Details")]
                 for chain_, chain_balance in details.items():
@@ -319,32 +321,25 @@ async def balance(
                             f"\n    {chain_}: [orange3]{displayable_amount(chain_balance, decimals=2)}[/orange3]"
                         )
                     ]
-            available_color = "bright_cyan" if balance_data["available_amount"] >= 0 else "red"
+            available_color = "bright_cyan" if available >= 0 else "red"
             infos += [
                 Text.from_markup(
-                    f"\n - Locked: [bright_cyan]{displayable_amount(balance_data['locked_amount'], decimals=2)}"
+                    f"\n - Locked: [bright_cyan]{displayable_amount(balance_data.locked_amount, decimals=2)}"
                     "[/bright_cyan]"
                 ),
                 Text.from_markup(
                     f"\n - Available: [{available_color}]"
-                    f"{displayable_amount(balance_data['available_amount'], decimals=2)}"
+                    f"{displayable_amount(available, decimals=2)}"
                     f"[/{available_color}]"
                 ),
             ]
 
-            try:
-                # Fetch user Credits
-                async with AlephHttpClient() as client:
-                    credits_balance = await client.get_balance(address).credit_balance
-                    infos += [
-                        Text("\nCredits:"),
-                        Text.from_markup(
-                            f"[bright_cyan] {displayable_amount(credits_balance, decimals=2)}[/bright_cyan]"
-                        ),
-                    ]
-            except Exception as e:
-                # In the case we call on ccn that does not support credits yet
-                logger.warning(f"Failed to fetch credits balance: {e}")
+            infos += [
+                Text("\nCredits:"),
+                Text.from_markup(
+                    f"[bright_cyan] {displayable_amount(balance_data.credit_balance, decimals=2)}[/bright_cyan]"
+                ),
+            ]
 
             # Get vouchers and add them to Account Info panel
             async with AuthenticatedAlephHttpClient(account=account) as client:

src/aleph_client/commands/credit.py

@@ -48,7 +48,7 @@ async def show(
 
     if address:
         async with AlephHttpClient(api_server=settings.API_HOST) as client:
-            credit = await client.get_balance(address=address)
+            credit = await client.get_balances(address=address)
             if json:
                 typer.echo(credit.model_dump_json(indent=4))
             else:
@@ -107,7 +107,7 @@ async def history(
                 table.add_column("Origin Ref")
                 table.add_column("Expiration Date")
 
-                for credit in filtered_credits.credit_balances:
+                for credit in filtered_credits.credit_history:
                     timestamp = Text(credit.message_timestamp.strftime("%Y-%m-%d %H:%M:%S"))
                     amount = Text(displayable_amount(credit.amount, decimals=2), style="cyan")
                     payment_method = Text(credit.payment_method if credit.payment_method else "-")

src/aleph_client/commands/instance/__init__.py

@@ -63,7 +63,6 @@
 from rich.text import Text
 
 from aleph_client.commands import help_strings
-from aleph_client.commands.account import get_balance
 from aleph_client.commands.instance.display import CRNTable, show_instances
 from aleph_client.commands.instance.network import (
     call_program_crn_list,
@@ -419,7 +418,9 @@ async def create(
     compute_unit_price = pricing.data[pricing_entity].price.get("compute_unit")
     if payment_type in [PaymentType.hold, PaymentType.superfluid]:
         # Early check with minimal cost (Gas + Aleph ERC20)
-        available_funds = Decimal(0 if is_stream else (await get_balance(address))["available_amount"])
+        balance_response = await client.get_balances(address)
+        available_amount = balance_response.balance - balance_response.locked_amount
+        available_funds = Decimal(0 if is_stream else available_amount)
         try:
             # Get compute_unit price from PricingPerEntity
             if is_stream and isinstance(account, ETHAccount):
@@ -451,7 +452,7 @@ async def create(
     if payment_type == PaymentType.credit:
         async with AlephHttpClient(api_server=settings.API_HOST) as client:
             try:
-                credit_info = await client.get_balance(address=address)
+                credit_info = await client.get_balances(address=address)
                 if isinstance(compute_unit_price, Price) and compute_unit_price.credit:
                     credit_price = Decimal(str(compute_unit_price.credit)) * tier.compute_units
                     if credit_info.credit_balance < credit_price:

src/aleph_client/commands/program.py

@@ -46,7 +46,6 @@
 from rich.text import Text
 
 from aleph_client.commands import help_strings
-from aleph_client.commands.account import get_balance
 from aleph_client.commands.pricing import PricingEntity, fetch_pricing_aggregate
 from aleph_client.commands.utils import (
     display_mounted_volumes,
@@ -248,7 +247,7 @@ async def upload(
             typer.echo(f"Failed to estimate program cost, error: {e}")
             raise typer.Exit(code=1) from e
 
-        available_funds = Decimal((await get_balance(address))["available_amount"])
+        available_funds = Decimal((await client.get_balances(address))["available_amount"])
         try:
             if available_funds < required_tokens:
                 raise InsufficientFundsError(TokenType.ALEPH, float(required_tokens), float(available_funds))

tests/unit/conftest.py

@@ -11,6 +11,7 @@
 import time
 from collections.abc import Generator
 from datetime import datetime, timezone
+from decimal import Decimal
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from unittest.mock import AsyncMock, MagicMock, patch
@@ -20,6 +21,7 @@
 from aleph.sdk.chains.ethereum import ETHAccount, get_fallback_private_key
 from aleph.sdk.client.services.crn import CrnList
 from aleph.sdk.client.services.pricing import PricingModel
+from aleph.sdk.query.responses import BalanceResponse
 from aleph.sdk.types import StoredContent, Voucher, VoucherAttribute
 from aleph_message.models import Chain, ItemHash, ItemType, StoreContent, StoreMessage
 from aleph_message.models.base import MessageType
@@ -530,3 +532,28 @@ def mock_voucher_service(mock_vouchers):
     mock_service.get_solana_vouchers = AsyncMock(return_value=[solana_voucher])
 
     return mock_service
+
+
+@pytest.fixture
+def mock_voucher_empty():
+    """Create a mock voucher service with pre-configured responses."""
+    mock_service = MagicMock()
+    mock_service.fetch_vouchers_by_chain = AsyncMock(return_value=[])
+    mock_service.get_vouchers = AsyncMock(return_value=[])
+    mock_service.get_evm_vouchers = AsyncMock(return_value=[])
+    mock_service.get_solana_vouchers = AsyncMock(return_value=[])
+
+    return mock_service
+
+
+@pytest.fixture
+def mock_get_balances():
+    # Create a proper BalanceResponse with all Decimal values
+    response = BalanceResponse(
+        address="0xCAfEcAfeCAfECaFeCaFecaFecaFECafECafeCaFe",
+        balance=Decimal(24853),
+        details={"AVAX": Decimal(4000), "BASE": Decimal(10000), "ETH": Decimal(10853)},
+        locked_amount=Decimal("4663.334518051392"),
+        credit_balance=5000,
+    )
+    return response

tests/unit/test_commands.py

@@ -16,6 +16,7 @@
 from aleph_client.commands.files import upload
 
 from .mocks import FAKE_STORE_HASH, FAKE_STORE_HASH_PUBLISHER
+from .test_instance import create_mock_client
 
 runner = CliRunner()
 
@@ -244,41 +245,49 @@ def test_account_sign_bytes(env_files):
     assert result.stdout.startswith("\nSignature:")
 
 
-def test_account_balance(mocker, env_files, mock_voucher_service):
+def test_account_balance(mocker, env_files, mock_voucher_service, mock_get_balances):
+    """
+    This test verifies that the account balance command correctly displays balance and voucher information.
+    """
+
     settings.CONFIG_FILE = env_files[1]
-    balance_response = {
-        "address": "0xCAfEcAfeCAfECaFeCaFecaFecaFECafECafeCaFe",
-        "balance": 24853,
-        "details": {"AVAX": 4000, "BASE": 10000, "ETH": 10853},
-        "locked_amount": 4663.334518051392,
-        "available_amount": 20189.665481948608,
-    }
+    mock_client_class, mock_client = create_mock_client(None, None, mock_get_balances=mock_get_balances)
 
-    mocker.patch("aleph_client.commands.account.get_balance", return_value=balance_response)
-    # TODO: used the mocked_client fixture instead (also need to move get_balance to the SDK)
-    mock_client = mocker.AsyncMock()
     mock_client.voucher = mock_voucher_service
-    mocker.patch("aleph_client.commands.account.AuthenticatedAlephHttpClient.__aenter__", return_value=mock_client)
+
+    # Replace both client types with our mock implementation
+    mocker.patch("aleph_client.commands.account.AlephHttpClient", mock_client_class)
+    mocker.patch("aleph_client.commands.account.AuthenticatedAlephHttpClient", mock_client_class)
 
     result = runner.invoke(
         app, ["account", "balance", "--address", "0xCAfEcAfeCAfECaFeCaFecaFecaFECafECafeCaFe", "--chain", "ETH"]
     )
+
     assert result.exit_code == 0
     assert result.stdout.startswith("╭─ Account Infos")
     assert "Available: 20189.67" in result.stdout
     assert "Vouchers:" in result.stdout
     assert "EVM Test Voucher" in result.stdout
 
 
-def test_account_balance_error(mocker, env_files):
+def test_account_balance_error(mocker, env_files, mock_voucher_empty):
     """Test error handling in the account balance command when API returns an error."""
     settings.CONFIG_FILE = env_files[1]
 
-    # Mock get_balance to raise an exception - simulating a non-200 response
-    mock_get_balance = mocker.patch(
-        "aleph_client.commands.account.get_balance",
-        side_effect=Exception("Failed to retrieve balance for address test. Status code: 404"),
+    mock_client_class = MagicMock()
+    mock_client = MagicMock()
+    mock_client.__aenter__.return_value = mock_client
+    mock_client.__aexit__.return_value = None
+    mock_client.get_balances = AsyncMock(
+        side_effect=Exception(
+            "Failed to retrieve balance for address 0xCAfEcAfeCAfECaFeCaFecaFecaFECafECafeCaFe. Status code: 404"
+        )
     )
+    mock_client.voucher = mock_voucher_empty
+    mock_client_class.return_value = mock_client
+
+    mocker.patch("aleph_client.commands.account.AlephHttpClient", mock_client_class)
+    mocker.patch("aleph_client.commands.account.AuthenticatedAlephHttpClient", mock_client_class)
 
     # Test with an address directly
     result = runner.invoke(
@@ -288,7 +297,6 @@ def test_account_balance_error(mocker, env_files):
     # The command should run without crashing but report the error
     assert result.exit_code == 0
     assert "Failed to retrieve balance for address" in result.stdout
-    mock_get_balance.assert_called_once()
 
 
 def test_account_vouchers_display(mocker, env_files, mock_voucher_service):

tests/unit/test_credits.py

@@ -17,7 +17,10 @@ def mock_credit_balance_response():
     mock_response.json = AsyncMock(
         return_value={
             "address": "0x1234567890123456789012345678901234567890",
-            "credits": 1000000000,
+            "balance": 24853,
+            "locked_amount": 4663.33,
+            "credit_balance": 1000000000,
+            "details": {"AVAX": 4000, "BASE": 10000, "ETH": 10853},
         }
     )
     return mock_response
@@ -32,7 +35,7 @@ def mock_credit_history_response():
     mock_response.json = AsyncMock(
         return_value={
             "address": "0x1234567890123456789012345678901234567890",
-            "credit_balances": [
+            "credit_history": [
                 {
                     "amount": 1000000000,
                     "message_timestamp": "2023-06-15T12:30:45Z",
@@ -124,10 +127,9 @@ async def run(mock_get):
 
     # Try to parse the output as JSON to validate it's properly formatted
     parsed_json = json.loads(captured.out)
-
     # Verify expected data is in the parsed JSON
     assert parsed_json["address"] == "0x1234567890123456789012345678901234567890"
-    assert parsed_json["credits"] == 1000000000
+    assert parsed_json["credit_balance"] == 1000000000
 
 
 @pytest.mark.asyncio
@@ -259,9 +261,9 @@ async def run(mock_get):
 
     # Verify expected data is in the parsed JSON
     assert parsed_json["address"] == "0x1234567890123456789012345678901234567890"
-    assert parsed_json["credit_balances"][0]["amount"] == 1000000000
-    assert parsed_json["credit_balances"][0]["payment_method"] == "credit_card"
-    assert len(parsed_json["credit_balances"]) == 2
+    assert parsed_json["credit_history"][0]["amount"] == 1000000000
+    assert parsed_json["credit_history"][0]["payment_method"] == "credit_card"
+    assert len(parsed_json["credit_history"]) == 2
 
 
 @pytest.mark.asyncio