feat (B2B Service): added async.

Author: RafaelJohn9

mpesakit/services/__init__.py

@@ -1,4 +1,4 @@
-from .b2b import B2BService
+from .b2b import B2BService, AsyncB2BService
 from .b2c import B2CService
 from .balance import BalanceService
 from .bill import BillService

mpesakit/services/b2b.py

@@ -1,10 +1,13 @@
 """Facade for M-Pesa B2B APIs (Express Checkout)."""
 
 from typing import Optional
-from mpesakit.auth import TokenManager
-from mpesakit.http_client import HttpClient
+from mpesakit.auth import TokenManager, AsyncTokenManager
+from mpesakit.http_client import HttpClient, AsyncHttpClient
+from mpesakit.b2b_express_checkout import AsyncB2BExpressCheckout
+from mpesakit.business_paybill import AsyncBusinessPayBill
 from mpesakit.business_buy_goods import (
     BusinessBuyGoods,
+    AsyncBusinessBuyGoods,
     BusinessBuyGoodsRequest,
     BusinessBuyGoodsResponse,
 )
@@ -186,3 +189,123 @@ def buygoods(
             },
         )
         return self._business_buygoods.buy_goods(request)
+
+class AsyncB2BService:
+    """Async facade for all M-Pesa B2B APIs."""
+
+    def __init__(self, http_client: AsyncHttpClient, token_manager: AsyncTokenManager) -> None:
+        """Initialize Async B2BService facade."""
+        self.http_client = http_client
+        self.token_manager = token_manager
+
+
+        self._express_checkout = AsyncB2BExpressCheckout(
+            http_client=self.http_client,
+            token_manager=self.token_manager,
+        )
+        self._business_paybill = AsyncBusinessPayBill(
+            http_client=self.http_client,
+            token_manager=self.token_manager,
+        )
+        self._business_buygoods = AsyncBusinessBuyGoods(
+            http_client=self.http_client,
+            token_manager=self.token_manager,
+        )
+
+    async def express_checkout(
+        self,
+        primary_short_code: str,
+        receiver_short_code: str,
+        amount: int,
+        payment_ref: str,
+        callback_url: str,
+        partner_name: str,
+        request_ref_id: str,
+        **kwargs,
+    ) -> B2BExpressCheckoutResponse:
+        """Initiate a B2B Express Checkout USSD Push transaction to another merchant."""
+        request = B2BExpressCheckoutRequest(
+            primaryShortCode=primary_short_code,
+            receiverShortCode=receiver_short_code,
+            amount=amount,
+            paymentRef=payment_ref,
+            callbackUrl=callback_url,
+            partnerName=partner_name,
+            RequestRefID=request_ref_id,
+            **{
+                k: v
+                for k, v in kwargs.items()
+                if k in B2BExpressCheckoutRequest.model_fields
+            },
+        )
+        return await self._express_checkout.ussd_push(request)
+
+    async def paybill(
+        self,
+        initiator: str,
+        security_credential: str,
+        amount: int,
+        party_a: int,
+        party_b: int,
+        account_reference: str,
+        requester: str,
+        remarks: str,
+        queue_timeout_url: str,
+        result_url: str,
+        **kwargs,
+    ) -> BusinessPayBillResponse:
+        """Initiate a Business PayBill transaction to another merchant."""
+        request = BusinessPayBillRequest(
+            Initiator=initiator,
+            SecurityCredential=security_credential,
+            Amount=amount,
+            PartyA=party_a,
+            PartyB=party_b,
+            AccountReference=account_reference,
+            Requester=requester,
+            Remarks=remarks,
+            QueueTimeOutURL=queue_timeout_url,
+            ResultURL=result_url,
+            **{
+                k: v
+                for k, v in kwargs.items()
+                if k in BusinessPayBillRequest.model_fields
+            },
+        )
+        return await self._business_paybill.paybill(request)
+
+    async def buygoods(
+        self,
+        initiator: str,
+        security_credential: str,
+        amount: int,
+        party_a: int,
+        party_b: int,
+        account_reference: str,
+        requester: str,
+        remarks: str,
+        queue_timeout_url: str,
+        result_url: str,
+        occassion: Optional[str] = None,
+        **kwargs,
+    ) -> BusinessBuyGoodsResponse:
+        """Initiate a Business Buy Goods transaction to another merchant."""
+        request = BusinessBuyGoodsRequest(
+            Initiator=initiator,
+            SecurityCredential=security_credential,
+            Amount=amount,
+            PartyA=party_a,
+            PartyB=party_b,
+            AccountReference=account_reference,
+            Requester=requester,
+            Remarks=remarks,
+            QueueTimeOutURL=queue_timeout_url,
+            ResultURL=result_url,
+            Occassion=occassion,
+            **{
+                k: v
+                for k, v in kwargs.items()
+                if k in BusinessBuyGoodsRequest.model_fields
+            },
+        )
+        return await self._business_buygoods.buy_goods(request)

tests/unit/services/test_b2b_service.py

@@ -3,7 +3,7 @@
 import pytest
 from unittest.mock import MagicMock
 
-from mpesakit.services.b2b import B2BService
+from mpesakit.services.b2b import B2BService, AsyncB2BService
 from mpesakit.business_buy_goods import (
     BusinessBuyGoodsResponse,
 )
@@ -13,8 +13,9 @@
 from mpesakit.b2b_express_checkout import (
     B2BExpressCheckoutResponse,
 )
-from mpesakit.auth import TokenManager
-from mpesakit.http_client import HttpClient
+from mpesakit.auth import TokenManager, AsyncTokenManager
+from mpesakit.http_client import HttpClient, AsyncHttpClient
+from unittest.mock import AsyncMock
 
 
 @pytest.fixture
@@ -30,6 +31,18 @@ def mock_http_client():
     """Mock HttpClient to simulate HTTP requests."""
     return MagicMock(spec=HttpClient)
 
+@pytest.fixture
+def mock_async_token_manager():
+    """Mock AsyncTokenManager to return a fixed token."""
+    mock = AsyncMock(spec=AsyncTokenManager)
+    mock.get_token.return_value = "async_test_token"
+    return mock
+
+
+@pytest.fixture
+def mock_async_http_client():
+    """Mock AsyncHttpClient to simulate async HTTP requests."""
+    return AsyncMock(spec=AsyncHttpClient)
 
 @pytest.fixture
 def b2b_service(mock_http_client, mock_token_manager):
@@ -156,3 +169,149 @@ def test_b2b_service_initializes_services_correctly(
     if hasattr(service, "buygoods_service"):
         assert service.buygoods_service.http_client is mock_http_client
         assert service.buygoods_service.token_manager is mock_token_manager
+        @pytest.fixture
+        def mock_async_http_client():
+            """Mock async HttpClient to simulate async HTTP requests."""
+            client = MagicMock(spec=HttpClient)
+            client.post = AsyncMock()
+            return client
+
+
+@pytest.fixture
+def async_b2b_service(mock_async_http_client, mock_async_token_manager):
+    """Fixture to create an AsyncB2BService instance with mocked dependencies."""
+    return AsyncB2BService(
+        http_client=mock_async_http_client,
+        token_manager=mock_async_token_manager
+    )
+
+
+@pytest.mark.asyncio
+async def test_async_express_checkout_calls_ussd_push(
+    async_b2b_service, mock_async_http_client
+):
+    """Test that async express_checkout calls the B2BExpressCheckout service."""
+    response_data = {"code": "0", "status": "USSD Initiated Successfully"}
+    mock_async_http_client.post.return_value = response_data
+
+    resp = await async_b2b_service.express_checkout(
+        primary_short_code="123456",
+        receiver_short_code="654321",
+        amount=100,
+        payment_ref="Invoice123",
+        callback_url="http://example.com/result",
+        partner_name="VendorName",
+        request_ref_id="550e8400-e29b-41d4-a716-446655440000",
+    )
+
+    assert isinstance(resp, B2BExpressCheckoutResponse)
+    assert resp.code == "0"
+    assert resp.status == "USSD Initiated Successfully"
+
+
+@pytest.mark.asyncio
+async def test_async_paybill_calls_paybill(async_b2b_service, mock_async_http_client):
+    """Test that async paybill calls the BusinessPayBill service."""
+    response_data = {
+        "OriginatorConversationID": "5118-111210482-1",
+        "ConversationID": "AG_20230420_2010759fd5662ef6d054",
+        "ResponseCode": "0",
+        "ResponseDescription": "Accept the service request successfully.",
+    }
+    mock_async_http_client.post.return_value = response_data
+
+    resp = await async_b2b_service.paybill(
+        initiator="apiuser",
+        security_credential="secure",
+        amount=200,
+        party_a=111111,
+        party_b=222222,
+        account_reference="Ref001",
+        requester="254700000000",
+        remarks="Test",
+        queue_timeout_url="http://timeout.url",
+        result_url="http://result.url",
+    )
+
+    assert isinstance(resp, BusinessPayBillResponse)
+    assert resp.is_successful() is True
+    assert resp.ResponseDescription == "Accept the service request successfully."
+
+
+@pytest.mark.asyncio
+async def test_async_buygoods_calls_buy_goods(
+    async_b2b_service, mock_async_http_client
+):
+    """Test that async buygoods calls the BusinessBuyGoods service."""
+    response_data = {
+        "OriginatorConversationID": "5118-111210482-1",
+        "ConversationID": "AG_20230420_2010759fd5662ef6d054",
+        "ResponseCode": "0",
+        "ResponseDescription": "Accept the service request successfully.",
+    }
+    mock_async_http_client.post.return_value = response_data
+
+    resp = await async_b2b_service.buygoods(
+        initiator="apiuser",
+        security_credential="secure",
+        amount=300,
+        party_a=333333,
+        party_b=444444,
+        account_reference="Ref002",
+        requester="254711111111",
+        remarks="BuyGoods",
+        queue_timeout_url="http://timeout.url",
+        result_url="http://result.url",
+        occassion="Occasion",
+    )
+
+    assert isinstance(resp, BusinessBuyGoodsResponse)
+    assert resp.is_successful() is True
+    assert resp.ResponseDescription == "Accept the service request successfully."
+
+
+@pytest.mark.asyncio
+async def test_async_express_checkout_filters_kwargs(
+    async_b2b_service, mock_async_http_client
+):
+    """Test that async express_checkout filters out unexpected kwargs."""
+    response_data = {"code": "0", "status": "USSD Initiated Successfully"}
+    mock_async_http_client.post.return_value = response_data
+
+    resp = await async_b2b_service.express_checkout(
+        primary_short_code="123456",
+        receiver_short_code="654321",
+        amount=100,
+        payment_ref="Invoice123",
+        callback_url="http://example.com/result",
+        partner_name="VendorName",
+        request_ref_id="550e8400-e29b-41d4-a716-446655440000",
+        unexpected_field="should be ignored",
+    )
+
+    assert isinstance(resp, B2BExpressCheckoutResponse)
+    assert resp.is_successful() is True
+    assert resp.status == "USSD Initiated Successfully"
+
+
+def test_async_b2b_service_initializes_services_correctly(
+    mock_async_http_client, mock_async_token_manager
+):
+    """Test AsyncB2BService initializes dependencies with correct arguments."""
+    service = AsyncB2BService(
+        http_client=mock_async_http_client,
+        token_manager=mock_async_token_manager,
+    )
+
+    assert service.http_client is mock_async_http_client
+    assert service.token_manager is mock_async_token_manager
+
+    if hasattr(service, "express_checkout_service"):
+        assert service.express_checkout_service.http_client is mock_async_http_client
+        assert service.express_checkout_service.token_manager is mock_async_token_manager
+    if hasattr(service, "paybill_service"):
+        assert service.paybill_service.http_client is mock_async_http_client
+        assert service.paybill_service.token_manager is mock_async_token_manager
+    if hasattr(service, "buygoods_service"):
+        assert service.buygoods_service.http_client is mock_async_http_client
+        assert service.buygoods_service.token_manager is mock_async_token_manager