Added Accounts account by id users endpoints e2e tests

Author: Robert Segal

e2e_config.test.json

@@ -9,6 +9,7 @@
   "accounts.module.id": "MOD-1756",
   "accounts.module.name": "Access Management",
   "accounts.seller.id": "SEL-7310-3075",
+  "accounts.user.id": "USR-9673-3314",
   "accounts.user_group.id": "UGR-6822-0561",
   "catalog.product.item.id": "ITM-7255-3950-0751",
   "catalog.product.document.id": "PDC-7255-3950-0001",

mpt_api_client/http/mixins.py

@@ -56,6 +56,24 @@ def update(self, resource_id: str, resource_data: ResourceData) -> Model:
         return self._resource_action(resource_id, "PUT", json=resource_data)  # type: ignore[attr-defined, no-any-return]
 
 
+class UpdateWithNoUpdateIdMixin[Model]:
+    """Update resource mixin without resource ID."""
+
+    def update(self, resource_data: ResourceData) -> Model:
+        """Update a resource using `PUT /endpoint`.
+
+        Args:
+            resource_data: Resource data.
+
+        Returns:
+            Resource object.
+
+        """
+        response = self.http_client.request("put", self.path, json=resource_data)  # type: ignore[attr-defined]
+
+        return self._model_class.from_response(response)  # type: ignore[attr-defined, no-any-return]
+
+
 class DownloadFileMixin[Model]:
     """Download file mixin."""
 
@@ -228,6 +246,24 @@ async def update(self, resource_id: str, resource_data: ResourceData) -> Model:
         return await self._resource_action(resource_id, "PUT", json=resource_data)  # type: ignore[attr-defined, no-any-return]
 
 
+class AsyncUpdateWithNoUpdateIdMixin[Model]:
+    """Update resource mixin without resource ID."""
+
+    async def update(self, resource_data: ResourceData) -> Model:
+        """Update a resource using `PUT /endpoint`.
+
+        Args:
+            resource_data: Resource data.
+
+        Returns:
+            Resource object.
+
+        """
+        response = await self.http_client.request("put", self.path, json=resource_data)  # type: ignore[attr-defined]
+
+        return self._model_class.from_response(response)  # type: ignore[attr-defined, no-any-return]
+
+
 class AsyncDownloadFileMixin[Model]:
     """Download file mixin."""
 
@@ -614,6 +650,18 @@ class AsyncModifiableResourceMixin[Model](
     """Editable resource mixin allows to read and update a resource resources."""
 
 
+class ModifiableResourceWithNoUpdateIdMixin[Model](
+    GetMixin[Model], UpdateWithNoUpdateIdMixin[Model], DeleteMixin
+):
+    """Editable resource mixin without resource ID to read and update a resource resources."""
+
+
+class AsyncModifiableResourceWithNoUpdateIdMixin[Model](
+    AsyncGetMixin[Model], AsyncUpdateWithNoUpdateIdMixin[Model], AsyncDeleteMixin
+):
+    """Editable resource mixin without resource ID to read and update a resource resources."""
+
+
 class ManagedResourceMixin[Model](CreateMixin[Model], ModifiableResourceMixin[Model]):
     """Managed resource mixin allows to read, create, update and delete a resource resources."""
 
@@ -622,3 +670,15 @@ class AsyncManagedResourceMixin[Model](
     AsyncCreateMixin[Model], AsyncModifiableResourceMixin[Model]
 ):
     """Managed resource mixin allows to read, create, update and delete a resource resources."""
+
+
+class ManagedResourceWithNoUpdateIdMixin[Model](
+    CreateMixin[Model], ModifiableResourceWithNoUpdateIdMixin[Model]
+):
+    """Managed resource mixin to read, create, update with no id and delete a resource resources."""
+
+
+class AsyncManagedResourceWithNoUpdateIdMixin[Model](
+    AsyncCreateMixin[Model], AsyncModifiableResourceWithNoUpdateIdMixin[Model]
+):
+    """Managed resource mixin to read, create, update with no id and delete a resource resources."""

mpt_api_client/resources/accounts/accounts_user_groups.py

@@ -1,9 +1,9 @@
 from mpt_api_client.http import AsyncService, Service
 from mpt_api_client.http.mixins import (
     AsyncCollectionMixin,
-    AsyncManagedResourceMixin,
+    AsyncManagedResourceWithNoUpdateIdMixin,
     CollectionMixin,
-    ManagedResourceMixin,
+    ManagedResourceWithNoUpdateIdMixin,
 )
 from mpt_api_client.models import Model
 
@@ -21,7 +21,7 @@ class AccountsUserGroupsServiceConfig:
 
 
 class AccountsUserGroupsService(
-    ManagedResourceMixin[AccountsUserGroup],
+    ManagedResourceWithNoUpdateIdMixin[AccountsUserGroup],
     CollectionMixin[AccountsUserGroup],
     Service[AccountsUserGroup],
     AccountsUserGroupsServiceConfig,
@@ -30,7 +30,7 @@ class AccountsUserGroupsService(
 
 
 class AsyncAccountsUserGroupsService(
-    AsyncManagedResourceMixin[AccountsUserGroup],
+    AsyncManagedResourceWithNoUpdateIdMixin[AccountsUserGroup],
     AsyncCollectionMixin[AccountsUserGroup],
     AsyncService[AccountsUserGroup],
     AccountsUserGroupsServiceConfig,

setup.cfg

@@ -44,12 +44,13 @@ per-file-ignores =
   mpt_api_client/rql/query_builder.py: WPS110 WPS115 WPS210 WPS214
   tests/unit/http/test_async_service.py: WPS204 WPS202
   tests/unit/http/test_service.py: WPS204 WPS202
-  tests/unit/http/test_mixins.py: WPS204 WPS202 WPS210
+  tests/unit/http/test_mixins.py: WPS204 WPS202 WPS210 WPS235 WPS402
   tests/unit/resources/catalog/test_products.py: WPS202 WPS210
   tests/unit/resources/accounts/*.py: WPS204 WPS202 WPS210
   tests/unit/resources/*/test_mixins.py: WPS118 WPS202 WPS204 WPS235
   tests/unit/test_mpt_client.py: WPS235
   tests/e2e/accounts/*.py: WPS430 WPS202
+  tests/e2e/accounts/accounts_users/*.py: WPS204 WPS202
   tests/e2e/catalog/*.py: WPS202 WPS421
   tests/e2e/catalog/items/*.py: WPS110 WPS202
 

tests/e2e/accounts/accounts_users/conftest.py

@@ -0,0 +1,38 @@
+import uuid
+
+import pytest
+
+
+@pytest.fixture
+def invalid_user_id():
+    return "USR-0000-0000"
+
+
+@pytest.fixture
+def account_user_factory(account_id, user_group_id):
+    def _account_user(  # noqa: WPS430
+        email: str = "e2e_created@dummy.com",  # Must be unique in Marketplace
+        first_name: str = "E2E Created",
+        last_name: str = "Account User",
+    ):
+        if not email:
+            email = f"e2e_{uuid.uuid4()!s}@dummy.com"
+
+        return {
+            "user": {
+                "firstName": first_name,
+                "lastName": last_name,
+                "email": email,
+            },
+            "account": {
+                "id": account_id,
+            },
+            "groups": [
+                {"id": user_group_id},
+            ],
+            "invitation": {
+                "status": "Invited",
+            },
+        }
+
+    return _account_user

tests/e2e/accounts/accounts_users/test_async_accounts_users.py

@@ -0,0 +1,197 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from mpt_api_client.rql.query_builder import RQLQuery
+
+pytestmark = [pytest.mark.flaky]
+
+
+@pytest.fixture
+async def created_account_user(async_mpt_vendor, account_user_factory, account_id):
+    ret_account_user = None
+
+    async def _created_account_user(  # noqa: WPS430
+        first_name: str = "E2E Created",
+        last_name: str = "Account User",
+    ):
+        nonlocal ret_account_user  # noqa: WPS420
+        account_user_data = account_user_factory(
+            first_name=first_name,
+            last_name=last_name,
+        )
+        ret_account_user = await async_mpt_vendor.accounts.accounts.users(
+            account_id=account_id
+        ).create(account_user_data)
+        return ret_account_user
+
+    yield _created_account_user
+
+    if ret_account_user:
+        try:
+            await async_mpt_vendor.accounts.accounts.users(account_id=account_id).delete(
+                ret_account_user.id
+            )
+        except MPTAPIError:
+            print(  # noqa: WPS421
+                f"TEARDOWN - Unable to delete account user {ret_account_user.id}",
+            )
+
+
+@pytest.fixture
+async def created_user_group(async_mpt_ops, user_group_factory):
+    new_user_group_request_data = user_group_factory()
+    created_user_group = await async_mpt_ops.accounts.user_groups.create(
+        new_user_group_request_data
+    )
+
+    yield created_user_group
+
+    try:
+        await async_mpt_ops.accounts.user_groups.delete(created_user_group.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete user group: {error.title}")  # noqa: WPS421
+
+
+@pytest.fixture
+async def created_account_user_group(
+    async_mpt_vendor, created_account_user, created_user_group, account_id
+):
+    created_account_user_data = await created_account_user()
+    user_group_data = created_user_group
+    create_user_group_data = {"id": user_group_data.id}
+    created_account_user_group = (
+        await async_mpt_vendor.accounts.accounts.users(account_id=account_id)
+        .groups(user_id=created_account_user_data.id)
+        .create(create_user_group_data)
+    )
+    yield created_account_user_group
+
+    try:
+        await (
+            async_mpt_vendor.accounts.accounts.users(account_id=account_id)
+            .groups(user_id=created_account_user_data.id)
+            .delete(user_group_data.id)
+        )
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete account user group: {error.title}")  # noqa: WPS421
+
+
+async def test_get_account_user_by_id(async_mpt_vendor, user_id, account_id):
+    account_user = await async_mpt_vendor.accounts.accounts.users(account_id=account_id).get(
+        user_id
+    )
+    assert account_user is not None
+
+
+async def test_list_account_users(async_mpt_vendor, account_id):
+    limit = 10
+
+    account_users = await async_mpt_vendor.accounts.accounts.users(
+        account_id=account_id
+    ).fetch_page(limit=limit)
+
+    assert len(account_users) > 0
+
+
+async def test_get_account_user_by_id_not_found(async_mpt_vendor, invalid_user_id, account_id):
+    with pytest.raises(MPTAPIError, match=r"404 Not Found"):
+        await async_mpt_vendor.accounts.accounts.users(account_id=account_id).get(invalid_user_id)
+
+
+async def test_filter_account_users(async_mpt_vendor, user_id, account_id):
+    select_fields = ["-name"]
+
+    filtered_account_users = (
+        async_mpt_vendor.accounts.accounts.users(account_id=account_id)
+        .filter(RQLQuery(id=user_id))
+        .select(*select_fields)
+    )
+
+    account_users = [user async for user in filtered_account_users.iterate()]
+
+    assert len(account_users) == 1
+
+
+async def test_create_account_user(created_account_user):
+    account_user_data = await created_account_user()
+    assert account_user_data is not None
+
+
+async def test_delete_account_user(async_mpt_vendor, created_account_user, account_id):
+    account_user_data = await created_account_user()
+    await async_mpt_vendor.accounts.accounts.users(account_id=account_id).delete(
+        account_user_data.id
+    )
+
+
+async def test_update_account_user(
+    async_mpt_vendor,
+    account_user_factory,
+    created_account_user,
+    account_id,
+):
+    account_user_data = await created_account_user()
+    updated_account_user_data = account_user_factory(
+        first_name="E2E Updated",
+        last_name="Account User",
+    )
+    updated_account_user = await async_mpt_vendor.accounts.accounts.users(
+        account_id=account_id
+    ).update(
+        account_user_data.id,
+        updated_account_user_data,
+    )
+    assert updated_account_user is not None
+
+
+async def test_account_user_resend_invite(
+    async_mpt_vendor,
+    created_account_user,
+    account_id,
+):
+    account_user_data = await created_account_user()
+    resend_invite = await async_mpt_vendor.accounts.accounts.users(
+        account_id=account_id
+    ).resend_invite(account_user_data.id)
+    assert resend_invite is not None
+
+
+def test_account_user_group_post(created_account_user_group):
+    created_account_user_group_data = created_account_user_group
+    assert created_account_user_group_data is not None
+
+
+async def test_account_user_group_update(
+    async_mpt_vendor,
+    created_account_user,
+    created_user_group,
+    account_id,
+):
+    created_account_user_data = await created_account_user()
+    update_user_group_data = [{"id": created_user_group.id}]
+    updated_account_user_group = (
+        await async_mpt_vendor.accounts.accounts.users(account_id=account_id)
+        .groups(user_id=created_account_user_data.id)
+        .update(update_user_group_data)
+    )
+    assert updated_account_user_group is not None
+
+
+async def test_account_user_group_delete(
+    async_mpt_vendor,
+    created_account_user,
+    created_user_group,
+    account_id,
+):
+    created_account_user_data = await created_account_user()
+    create_user_group_data = {"id": created_user_group.id}
+    (
+        await async_mpt_vendor.accounts.accounts.users(account_id=account_id)
+        .groups(user_id=created_account_user_data.id)
+        .create(create_user_group_data)
+    )
+    (
+        await async_mpt_vendor.accounts.accounts.users(account_id=account_id)
+        .groups(user_id=created_account_user_data.id)
+        .delete(created_user_group.id)
+    )