Adding accounts endpoints

Author: Robert Segal

mpt_api_client/mpt_client.py

@@ -2,6 +2,8 @@
 
 from mpt_api_client.http import AsyncHTTPClient, HTTPClient
 from mpt_api_client.resources import (
+    Accounts,
+    AsyncAccounts,
     AsyncAudit,
     AsyncBilling,
     AsyncCatalog,
@@ -56,6 +58,11 @@ def billing(self) -> AsyncBilling:
         """Billing MPT API Client."""
         return AsyncBilling(http_client=self.http_client)
 
+    @property
+    def accounts(self) -> AsyncAccounts:
+        """Accounts MPT API Client."""
+        return AsyncAccounts(http_client=self.http_client)
+
 
 class MPTClient:
     """MPT API Client."""
@@ -104,3 +111,8 @@ def audit(self) -> Audit:
     def billing(self) -> Billing:
         """Billing MPT API Client."""
         return Billing(http_client=self.http_client)
+
+    @property
+    def accounts(self) -> Accounts:
+        """Accounts MPT API Client."""
+        return Accounts(http_client=self.http_client)

mpt_api_client/resources/__init__.py

@@ -1,9 +1,12 @@
+from mpt_api_client.resources.accounts import Accounts, AsyncAccounts
 from mpt_api_client.resources.audit import AsyncAudit, Audit
 from mpt_api_client.resources.billing import AsyncBilling, Billing
 from mpt_api_client.resources.catalog import AsyncCatalog, Catalog
 from mpt_api_client.resources.commerce import AsyncCommerce, Commerce
 
 __all__ = [  # noqa: WPS410
+    "Accounts",
+    "AsyncAccounts",
     "AsyncAudit",
     "AsyncBilling",
     "AsyncCatalog",

mpt_api_client/resources/accounts/__init__.py

@@ -0,0 +1,3 @@
+from mpt_api_client.resources.accounts.accounts import Accounts, AsyncAccounts
+
+__all__ = ["Accounts", "AsyncAccounts"]  # noqa: WPS410

mpt_api_client/resources/accounts/account.py

@@ -0,0 +1,48 @@
+from mpt_api_client.http import AsyncService, Service
+from mpt_api_client.http.mixins import (
+    AsyncCreateMixin,
+    AsyncUpdateMixin,
+    CreateMixin,
+    UpdateMixin,
+)
+from mpt_api_client.models import Model
+from mpt_api_client.resources.accounts.mixins import (
+    ActivatableMixin,
+    AsyncActivatableMixin,
+    AsyncValidateMixin,
+    ValidateMixin,
+)
+
+
+class Account(Model):
+    """Account resource."""
+
+
+class AccountsServiceConfig:
+    """Accounts service configuration."""
+
+    _endpoint = "/public/v1/accounts"
+    _model_class = Account
+    _collection_key = "data"
+
+
+class AccountsService(
+    CreateMixin[Account],
+    UpdateMixin[Account],
+    ActivatableMixin[Account],
+    ValidateMixin[Account],
+    Service[Account],
+    AccountsServiceConfig,
+):
+    """Accounts service."""
+
+
+class AsyncAccountsService(
+    AsyncCreateMixin[Account],
+    AsyncUpdateMixin[Account],
+    AsyncActivatableMixin[Account],
+    AsyncValidateMixin[Account],
+    AsyncService[Account],
+    AccountsServiceConfig,
+):
+    """Async Accounts service."""

mpt_api_client/resources/accounts/accounts.py

@@ -0,0 +1,26 @@
+from mpt_api_client.http import AsyncHTTPClient, HTTPClient
+from mpt_api_client.resources.accounts.account import AccountsService, AsyncAccountsService
+
+
+class Accounts:
+    """Accounts MPT API Module."""
+
+    def __init__(self, *, http_client: HTTPClient):
+        self.http_client = http_client
+
+    @property
+    def accounts(self) -> AccountsService:
+        """Accounts service."""
+        return AccountsService(http_client=self.http_client)
+
+
+class AsyncAccounts:
+    """Async Accounts MPT API Module."""
+
+    def __init__(self, *, http_client: AsyncHTTPClient):
+        self.http_client = http_client
+
+    @property
+    def accounts(self) -> AsyncAccountsService:
+        """Accounts service."""
+        return AsyncAccountsService(http_client=self.http_client)

mpt_api_client/resources/accounts/mixins.py

@@ -0,0 +1,132 @@
+from mpt_api_client.models import ResourceData
+
+# TODO: Consider reorganizing functions in mixins to reduce duplication and differences amongst
+#       different domains
+
+
+class ActivatableMixin[Model]:
+    """Activatable mixin for activating, enabling, disabling and deactivating resources."""
+
+    def activate(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Activate a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "activate", json=resource_data
+        )
+
+    def deactivate(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Deactivate a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "deactivate", json=resource_data
+        )
+
+    def enable(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Enable a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "enable", json=resource_data
+        )
+
+    def disable(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Disable a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "disable", json=resource_data
+        )
+
+
+class ValidateMixin[Model]:
+    """Validate mixin adds the ability to validate a resource."""
+
+    def validate(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Validate a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be validated
+        """
+        return self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "validate", json=resource_data
+        )
+
+
+class AsyncActivatableMixin[Model]:
+    """Async activatable mixin for activating, enabling, disabling and deactivating resources."""
+
+    async def activate(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Activate a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return await self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "activate", json=resource_data
+        )
+
+    async def deactivate(
+        self, resource_id: str, resource_data: ResourceData | None = None
+    ) -> Model:
+        """Deactivate a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return await self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "deactivate", json=resource_data
+        )
+
+    async def enable(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Enable a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return await self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "enable", json=resource_data
+        )
+
+    async def disable(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Disable a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be updated
+        """
+        return await self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "disable", json=resource_data
+        )
+
+
+class AsyncValidateMixin[Model]:
+    """Asynchronous Validate mixin adds the ability to validate a resource."""
+
+    async def validate(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Validate a resource.
+
+        Args:
+            resource_id: Resource ID
+            resource_data: Resource data will be validated
+        """
+        return await self._resource_action(  # type: ignore[attr-defined, no-any-return]
+            resource_id, "POST", "validate", json=resource_data
+        )

setup.cfg

@@ -32,18 +32,21 @@ extend-ignore =
 
 
 per-file-ignores =
+  mpt_api_client/resources/accounts/*.py: WPS215
   mpt_api_client/resources/audit/*.py: WPS215
   mpt_api_client/resources/billing/*.py: WPS215 WPS202 WPS214 WPS204
   mpt_api_client/resources/catalog/*.py: WPS110 WPS215 WPS214
   mpt_api_client/resources/commerce/*.py: WPS215
   mpt_api_client/rql/query_builder.py: WPS110 WPS115 WPS210 WPS214
   mpt_api_client/resources/catalog/products.py: WPS204 WPS214 WPS215
   mpt_api_client/http/mixins.py: WPS202
+  mpt_api_client/mpt_client.py: WPS235
   tests/http/test_async_service.py: WPS204 WPS202
   tests/http/test_service.py: WPS204 WPS202
   tests/http/test_mixins.py: WPS204 WPS202
   tests/resources/catalog/test_products.py: WPS202 WPS210
   tests/resources/*/test_mixins.py: WPS118 WPS202 WPS204
+  tests/test_mpt.py: WPS210 WPS218 WPS235
 
   tests/*:
     # Allow magic strings.

tests/resources/accounts/test_account.py

@@ -0,0 +1,27 @@
+import pytest
+
+from mpt_api_client.resources.accounts.account import AccountsService, AsyncAccountsService
+
+
+@pytest.fixture
+def account_service(http_client):
+    return AccountsService(http_client=http_client)
+
+
+@pytest.fixture
+def async_account_service(async_http_client):
+    return AsyncAccountsService(http_client=async_http_client)
+
+
+@pytest.mark.parametrize(
+    "method", ["get", "create", "update", "enable", "disable", "activate", "deactivate", "validate"]
+)
+def test_mixins_present(account_service, method):
+    assert hasattr(account_service, method)
+
+
+@pytest.mark.parametrize(
+    "method", ["get", "create", "update", "enable", "disable", "activate", "deactivate", "validate"]
+)
+def test_async_mixins_present(async_account_service, method):
+    assert hasattr(async_account_service, method)

tests/resources/accounts/test_accounts.py

@@ -0,0 +1,50 @@
+import pytest
+
+from mpt_api_client.resources.accounts.account import AccountsService, AsyncAccountsService
+from mpt_api_client.resources.accounts.accounts import Accounts, AsyncAccounts
+
+
+@pytest.fixture
+def accounts(http_client):
+    return Accounts(http_client=http_client)
+
+
+@pytest.fixture
+def async_accounts(async_http_client):
+    return AsyncAccounts(http_client=async_http_client)
+
+
+@pytest.mark.parametrize(
+    ("property_name", "expected_service_class"), [("accounts", AccountsService)]
+)
+def test_accounts_properties(accounts, property_name, expected_service_class):
+    """Test that Accounts properties return correct instances."""
+    service = getattr(accounts, property_name)
+
+    assert isinstance(service, expected_service_class)
+    assert service.http_client is accounts.http_client
+
+
+@pytest.mark.parametrize(
+    ("property_name", "expected_service_class"), [("accounts", AsyncAccountsService)]
+)
+def test_async_accounts_properties(async_accounts, property_name, expected_service_class):
+    """Test that AsyncAccounts properties return correct instances."""
+    service = getattr(async_accounts, property_name)
+
+    assert isinstance(service, expected_service_class)
+    assert service.http_client is async_accounts.http_client
+
+
+def test_accounts_initialization(http_client):
+    accounts = Accounts(http_client=http_client)
+
+    assert accounts.http_client is http_client
+    assert isinstance(accounts, Accounts)
+
+
+def test_async_accounts_initialization(async_http_client):
+    accounts = AsyncAccounts(http_client=async_http_client)
+
+    assert accounts.http_client is async_http_client
+    assert isinstance(accounts, AsyncAccounts)