MPT-19906: add /integration/extensions/{id}/terms service

e2e_config.test.json

@@ -67,5 +67,5 @@
   "notifications.category.id": "NTC-6157-0397",
   "notifications.message.id": "MSG-0000-6215-1019-0139",
   "notifications.subscriber.id": "NTS-0829-7123-7123",
-  "integration.extension.id": "EXT-4401-0953"
+  "integration.extension.id": "EXT-6587-4477"
 }

mpt_api_client/resources/integration/extension_term_variants.py

@@ -0,0 +1,34 @@
+from mpt_api_client.http import AsyncService, Service
+from mpt_api_client.http.mixins import (
+    AsyncCollectionMixin,
+    CollectionMixin,
+)
+from mpt_api_client.models import Model
+
+
+class ExtensionTermVariant(Model):
+    """Extension Term Variant resource (stub)."""
+
+
+class ExtensionTermVariantsServiceConfig:
+    """Extension Term Variants service configuration."""
+
+    _endpoint = "/public/v1/integration/extensions/{extension_id}/terms/{term_id}/variants"
+    _model_class = ExtensionTermVariant
+    _collection_key = "data"
+
+
+class ExtensionTermVariantsService(
+    CollectionMixin[ExtensionTermVariant],
+    Service[ExtensionTermVariant],
+    ExtensionTermVariantsServiceConfig,
+):
+    """Sync service for extension term variants (stub)."""
+
+
+class AsyncExtensionTermVariantsService(
+    AsyncCollectionMixin[ExtensionTermVariant],
+    AsyncService[ExtensionTermVariant],
+    ExtensionTermVariantsServiceConfig,
+):
+    """Async service for extension term variants (stub)."""

mpt_api_client/resources/integration/extension_terms.py

@@ -0,0 +1,87 @@
+from mpt_api_client.http import AsyncService, Service
+from mpt_api_client.http.mixins import (
+    AsyncCollectionMixin,
+    AsyncManagedResourceMixin,
+    CollectionMixin,
+    ManagedResourceMixin,
+)
+from mpt_api_client.models import Model
+from mpt_api_client.models.model import BaseModel
+from mpt_api_client.resources.integration.extension_term_variants import (
+    AsyncExtensionTermVariantsService,
+    ExtensionTermVariantsService,
+)
+from mpt_api_client.resources.integration.mixins import (
+    AsyncPublishableMixin,
+    PublishableMixin,
+)
+
+
+class ExtensionTerm(Model):
+    """Extension Term resource.
+
+    Attributes:
+        name: Term name.
+        revision: Revision number.
+        description: Term description.
+        display_order: Display order of the term.
+        status: Term status (Draft, Published, Unpublished, Deleted).
+        extension: Reference to the parent extension.
+        audit: Audit information (created, updated, published, unpublished events).
+    """
+
+    name: str | None
+    revision: int | None
+    description: str | None
+    display_order: int | None
+    status: str | None
+    extension: BaseModel | None
+    audit: BaseModel | None
+
+
+class ExtensionTermsServiceConfig:
+    """Extension Terms service configuration."""
+
+    _endpoint = "/public/v1/integration/extensions/{extension_id}/terms"
+    _model_class = ExtensionTerm
+    _collection_key = "data"
+
+
+class ExtensionTermsService(
+    PublishableMixin[ExtensionTerm],
+    ManagedResourceMixin[ExtensionTerm],
+    CollectionMixin[ExtensionTerm],
+    Service[ExtensionTerm],
+    ExtensionTermsServiceConfig,
+):
+    """Sync service for the /public/v1/integration/extensions/{extensionId}/terms endpoint."""
+
+    def variants(self, term_id: str) -> ExtensionTermVariantsService:
+        """Access extension term variants service."""
+        return ExtensionTermVariantsService(
+            http_client=self.http_client,
+            endpoint_params={
+                "extension_id": self.endpoint_params["extension_id"],
+                "term_id": term_id,
+            },
+        )
+
+
+class AsyncExtensionTermsService(
+    AsyncPublishableMixin[ExtensionTerm],
+    AsyncManagedResourceMixin[ExtensionTerm],
+    AsyncCollectionMixin[ExtensionTerm],
+    AsyncService[ExtensionTerm],
+    ExtensionTermsServiceConfig,
+):
+    """Async service for the /public/v1/integration/extensions/{extensionId}/terms endpoint."""
+
+    def variants(self, term_id: str) -> AsyncExtensionTermVariantsService:
+        """Access async extension term variants service."""
+        return AsyncExtensionTermVariantsService(
+            http_client=self.http_client,
+            endpoint_params={
+                "extension_id": self.endpoint_params["extension_id"],
+                "term_id": term_id,
+            },
+        )

mpt_api_client/resources/integration/extensions.py

@@ -13,6 +13,10 @@
 )
 from mpt_api_client.models import Model
 from mpt_api_client.models.model import BaseModel
+from mpt_api_client.resources.integration.extension_terms import (
+    AsyncExtensionTermsService,
+    ExtensionTermsService,
+)
 from mpt_api_client.resources.integration.mixins import (
     AsyncExtensionMixin,
     ExtensionMixin,
@@ -79,6 +83,12 @@ class ExtensionsService(
 ):
     """Sync service for the /public/v1/integration/extensions endpoint."""
 
+    def terms(self, extension_id: str) -> ExtensionTermsService:
+        """Return extension terms service."""
+        return ExtensionTermsService(
+            http_client=self.http_client, endpoint_params={"extension_id": extension_id}
+        )
+
 
 class AsyncExtensionsService(
     AsyncExtensionMixin[Extension],
@@ -91,3 +101,9 @@ class AsyncExtensionsService(
     ExtensionsServiceConfig,
 ):
     """Async service for the /public/v1/integration/extensions endpoint."""
+
+    def terms(self, extension_id: str) -> AsyncExtensionTermsService:
+        """Return async extension terms service."""
+        return AsyncExtensionTermsService(
+            http_client=self.http_client, endpoint_params={"extension_id": extension_id}
+        )

mpt_api_client/resources/integration/mixins/__init__.py

@@ -2,8 +2,14 @@
     AsyncExtensionMixin,
     ExtensionMixin,
 )
+from mpt_api_client.resources.integration.mixins.publishable_mixin import (
+    AsyncPublishableMixin,
+    PublishableMixin,
+)
 
 __all__ = [  # noqa: WPS410
     "AsyncExtensionMixin",
+    "AsyncPublishableMixin",
     "ExtensionMixin",
+    "PublishableMixin",
 ]

mpt_api_client/resources/integration/mixins/publishable_mixin.py

@@ -0,0 +1,57 @@
+from mpt_api_client.models import ResourceData
+
+
+class PublishableMixin[Model]:
+    """Publishable mixin adds the ability to publish and unpublish a resource."""
+
+    def publish(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Publish the resource.
+
+        Args:
+            resource_id: Resource ID.
+            resource_data: Optional request body.
+
+        Returns:
+            Updated resource.
+        """
+        return self._resource(resource_id).post("publish", json=resource_data)  # type: ignore[attr-defined, no-any-return]
+
+    def unpublish(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Unpublish the resource.
+
+        Args:
+            resource_id: Resource ID.
+            resource_data: Optional request body.
+
+        Returns:
+            Updated resource.
+        """
+        return self._resource(resource_id).post("unpublish", json=resource_data)  # type: ignore[attr-defined, no-any-return]
+
+
+class AsyncPublishableMixin[Model]:
+    """Async publishable mixin adds the ability to publish and unpublish a resource."""
+
+    async def publish(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Publish the resource.
+
+        Args:
+            resource_id: Resource ID.
+            resource_data: Optional request body.
+
+        Returns:
+            Updated resource.
+        """
+        return await self._resource(resource_id).post("publish", json=resource_data)  # type: ignore[attr-defined, no-any-return]
+
+    async def unpublish(self, resource_id: str, resource_data: ResourceData | None = None) -> Model:
+        """Unpublish the resource.
+
+        Args:
+            resource_id: Resource ID.
+            resource_data: Optional request body.
+
+        Returns:
+            Updated resource.
+        """
+        return await self._resource(resource_id).post("unpublish", json=resource_data)  # type: ignore[attr-defined, no-any-return]

tests/e2e/integration/extension_terms/conftest.py

@@ -0,0 +1,51 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+
+
+@pytest.fixture(scope="session")
+def extension_id(e2e_config):
+    return e2e_config["integration.extension.id"]
+
+
+@pytest.fixture
+def extension_terms_service(mpt_vendor, extension_id):
+    return mpt_vendor.integration.extensions.terms(extension_id)
+
+
+@pytest.fixture
+def async_extension_terms_service(async_mpt_vendor, extension_id):
+    return async_mpt_vendor.integration.extensions.terms(extension_id)
+
+
+@pytest.fixture
+def term_data(short_uuid):
+    return {
+        "name": f"e2e - please delete {short_uuid}",
+        "description": "Created by automated E2E tests. Safe to delete.",
+        "displayOrder": 1,
+    }
+
+
+@pytest.fixture
+def created_term(extension_terms_service, term_data):
+    term = extension_terms_service.create(term_data)
+
+    yield term
+
+    try:
+        extension_terms_service.delete(term.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete term {term.id}: {error.title}")  # noqa: WPS421
+
+
+@pytest.fixture
+async def async_created_term(async_extension_terms_service, term_data):
+    term = await async_extension_terms_service.create(term_data)
+
+    yield term
+
+    try:
+        await async_extension_terms_service.delete(term.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete term {term.id}: {error.title}")  # noqa: WPS421

tests/e2e/integration/extension_terms/test_async_extension_terms.py

@@ -0,0 +1,45 @@
+import pytest
+
+from tests.e2e.helper import assert_async_service_filter_with_iterate
+
+pytestmark = [
+    pytest.mark.flaky,
+]
+
+
+def test_create_extension_term(async_created_term, term_data):
+    result = async_created_term.name
+
+    assert result == term_data["name"]
+
+
+async def test_filter_extension_terms(async_extension_terms_service, async_created_term):
+    await assert_async_service_filter_with_iterate(
+        async_extension_terms_service, async_created_term.id, None
+    )  # act
+
+
+async def test_update_extension_term(async_extension_terms_service, async_created_term, short_uuid):
+    update_data = {"name": f"e2e updated {short_uuid}"}
+
+    result = await async_extension_terms_service.update(async_created_term.id, update_data)
+
+    assert result.name == update_data["name"]
+
+
+async def test_publish_extension_term(async_extension_terms_service, async_created_term):
+    result = await async_extension_terms_service.publish(async_created_term.id)
+
+    assert result.status == "Published"
+
+
+async def test_unpublish_extension_term(async_extension_terms_service, async_created_term):
+    await async_extension_terms_service.publish(async_created_term.id)
+
+    result = await async_extension_terms_service.unpublish(async_created_term.id)
+
+    assert result.status == "Unpublished"
+
+
+async def test_delete_extension_term(async_extension_terms_service, async_created_term):
+    await async_extension_terms_service.delete(async_created_term.id)  # act

tests/e2e/integration/extension_terms/test_sync_extension_terms.py

@@ -0,0 +1,43 @@
+import pytest
+
+from tests.e2e.helper import assert_service_filter_with_iterate
+
+pytestmark = [
+    pytest.mark.flaky,
+]
+
+
+def test_create_extension_term(created_term, term_data):
+    result = created_term.name
+
+    assert result == term_data["name"]
+
+
+def test_filter_extension_terms(extension_terms_service, created_term):
+    assert_service_filter_with_iterate(extension_terms_service, created_term.id, None)  # act
+
+
+def test_update_extension_term(extension_terms_service, created_term, short_uuid):
+    update_data = {"name": f"e2e updated {short_uuid}"}
+
+    result = extension_terms_service.update(created_term.id, update_data)
+
+    assert result.name == update_data["name"]
+
+
+def test_publish_extension_term(extension_terms_service, created_term):
+    result = extension_terms_service.publish(created_term.id)
+
+    assert result.status == "Published"
+
+
+def test_unpublish_extension_term(extension_terms_service, created_term):
+    extension_terms_service.publish(created_term.id)
+
+    result = extension_terms_service.unpublish(created_term.id)
+
+    assert result.status == "Unpublished"
+
+
+def test_delete_extension_term(extension_terms_service, created_term):
+    extension_terms_service.delete(created_term.id)  # act