MPT-14891 E2E for product terms and variants

Author: albertsola

e2e_config.test.json

@@ -16,5 +16,7 @@
   "catalog.product.item_group.id": "IGR-7255-3950-0001",
   "catalog.product.parameter.id": "PAR-7255-3950-0016",
   "catalog.product.parameter_group.id": "PGR-7255-3950-0001",
+  "catalog.product.terms.id": "TCS-7255-3950-0001",
+  "catalog.product.terms.variant.id": "TCV-7255-3950-0001-0001",
   "catalog.unit.id": "UNT-1229"
 }

mpt_api_client/resources/catalog/product_term_variants.py

@@ -1,15 +1,17 @@
 from mpt_api_client.http import AsyncService, Service
 from mpt_api_client.http.mixins import (
     AsyncCollectionMixin,
-    AsyncFilesOperationsMixin,
+    AsyncDownloadFileMixin,
     AsyncModifiableResourceMixin,
     CollectionMixin,
-    FilesOperationsMixin,
+    DownloadFileMixin,
     ModifiableResourceMixin,
 )
 from mpt_api_client.models import Model
 from mpt_api_client.resources.catalog.mixins import (
+    AsyncCreateFileMixin,
     AsyncPublishableMixin,
+    CreateFileMixin,
     PublishableMixin,
 )
 
@@ -21,13 +23,14 @@ class TermVariant(Model):
 class TermVariantServiceConfig:
     """Term variant service configuration."""
 
-    _endpoint = "/public/v1/catalog/products/terms/{term_id}/variants"
+    _endpoint = "/public/v1/catalog/products/{product_id}/terms/{term_id}/variants"
     _model_class = TermVariant
     _collection_key = "data"
 
 
 class TermVariantService(
-    FilesOperationsMixin[TermVariant],
+    CreateFileMixin[TermVariant],
+    DownloadFileMixin[TermVariant],
     ModifiableResourceMixin[TermVariant],
     PublishableMixin[TermVariant],
     CollectionMixin[TermVariant],
@@ -36,13 +39,20 @@ class TermVariantService(
 ):
     """Term variant service."""
 
+    _upload_file_key = "file"
+    _upload_data_key = "variant"
+
 
 class AsyncTermVariantService(
-    AsyncFilesOperationsMixin[TermVariant],
+    AsyncCreateFileMixin[TermVariant],
+    AsyncDownloadFileMixin[TermVariant],
     AsyncModifiableResourceMixin[TermVariant],
     AsyncPublishableMixin[TermVariant],
     AsyncCollectionMixin[TermVariant],
     AsyncService[TermVariant],
     TermVariantServiceConfig,
 ):
     """Async Term variant service."""
+
+    _upload_file_key = "file"
+    _upload_data_key = "variant"

mpt_api_client/resources/catalog/product_terms.py

@@ -38,7 +38,7 @@ def variants(self, term_id: str) -> TermVariantService:
         """Access term variants service."""
         return TermVariantService(
             http_client=self.http_client,
-            endpoint_params={"term_id": term_id},
+            endpoint_params={"product_id": self.endpoint_params["product_id"], "term_id": term_id},
         )
 
 
@@ -55,5 +55,5 @@ def variants(self, term_id: str) -> AsyncTermVariantService:
         """Access async term variants service."""
         return AsyncTermVariantService(
             http_client=self.http_client,
-            endpoint_params={"term_id": term_id},
+            endpoint_params={"product_id": self.endpoint_params["product_id"], "term_id": term_id},
         )

tests/e2e/catalog/product/documents/conftest.py

@@ -12,6 +12,7 @@ def document_data():
         "name": "e2e test document - please delete",
         "description": "E2E test document for automated testing",
         "language": "en-gb",
+        "url": "",
     }
 
 

tests/e2e/catalog/product/documents/test_sync_document.py

@@ -18,7 +18,7 @@ def created_document_from_file(logger, vendor_document_service, document_data, p
 
 
 @pytest.fixture
-def created_document_from_link(logger, vendor_document_service, document_data, pdf_url):
+def created_document_from_url(logger, vendor_document_service, document_data, pdf_url):
     document_data["url"] = pdf_url
     document = vendor_document_service.create(document_data)
     yield document
@@ -33,9 +33,9 @@ def test_create_document(created_document_from_file, document_data):
     assert created_document_from_file.description == document_data["description"]
 
 
-def test_create_from_link(created_document_from_link, pdf_url, document_data):
-    assert created_document_from_link.name == document_data["name"]
-    assert created_document_from_link.description == document_data["description"]
+def test_create_document_from_url(created_document_from_url, document_data):
+    assert created_document_from_url.name == document_data["name"]
+    assert created_document_from_url.description == document_data["description"]
 
 
 def test_update_document(vendor_document_service, created_document_from_file):

tests/e2e/catalog/product/terms/conftest.py

@@ -0,0 +1,11 @@
+import pytest
+
+
+@pytest.fixture
+def term_data():
+    return {"name": "e2e - please delete", "description": "Test term description"}
+
+
+@pytest.fixture
+def term_id(e2e_config):
+    return e2e_config["catalog.product.terms.id"]

tests/e2e/catalog/product/terms/test_async_terms.py

@@ -0,0 +1,67 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from mpt_api_client.rql.query_builder import RQLQuery
+
+pytestmark = [pytest.mark.flaky]
+
+
+@pytest.fixture
+def async_vendor_terms_service(async_mpt_vendor, product_id):
+    return async_mpt_vendor.catalog.products.terms(product_id)
+
+
+@pytest.fixture
+async def async_created_term(async_vendor_terms_service, term_data):
+    service = async_vendor_terms_service
+    term = await service.create(term_data)
+    yield term
+    try:
+        await service.delete(term.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete term {term.id}: {error.title}")
+
+
+def test_create_term(async_created_term):
+    term = async_created_term
+    assert term.name == "e2e - please delete"
+
+
+async def test_update_term(async_vendor_terms_service, async_created_term):
+    service = async_vendor_terms_service
+    update_data = {"name": "e2e - delete me (updated)"}
+    term = await service.update(async_created_term.id, update_data)
+    assert term.name == "e2e - delete me (updated)"
+
+
+async def test_get_term(async_vendor_terms_service, term_id):
+    service = async_vendor_terms_service
+    term = await service.get(term_id)
+    assert term.id == term_id
+
+
+async def test_get_term_by_id(async_vendor_terms_service, term_id):
+    service = async_vendor_terms_service
+    term = await service.get(term_id)
+    assert term.id == term_id
+
+
+async def test_iterate_terms(async_vendor_terms_service, async_created_term):
+    service = async_vendor_terms_service
+    terms = [term async for term in service.iterate()]
+    assert any(term.id == async_created_term.id for term in terms)
+
+
+async def test_filter_terms(async_vendor_terms_service, term_id):
+    select_fields = ["-description"]
+    filtered_terms = async_vendor_terms_service.filter(RQLQuery(id=term_id)).select(*select_fields)
+    terms = [term async for term in filtered_terms.iterate()]
+    assert len(terms) == 1
+    assert terms[0].id == term_id
+
+
+async def test_delete_term(async_vendor_terms_service, async_created_term):
+    service = async_vendor_terms_service
+    await service.delete(async_created_term.id)
+    with pytest.raises(MPTAPIError):
+        await service.get(async_created_term.id)

tests/e2e/catalog/product/terms/test_sync_terms.py

@@ -0,0 +1,79 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from mpt_api_client.rql.query_builder import RQLQuery
+
+pytestmark = [pytest.mark.flaky]
+
+
+@pytest.fixture
+def vendor_terms_service(mpt_vendor, product_id):
+    return mpt_vendor.catalog.products.terms(product_id)
+
+
+@pytest.fixture
+def created_term(logger, vendor_terms_service, term_data):
+    service = vendor_terms_service
+    term = service.create(term_data)
+    yield term
+    try:
+        service.delete(term.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete term {term.id}: {error.title}")
+
+
+@pytest.fixture
+def created_term_from_url(logger, vendor_terms_service, term_data, pdf_url):
+    term_data["url"] = pdf_url
+    service = vendor_terms_service
+    term = service.create(term_data)
+    yield term
+    try:
+        service.delete(term.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete term {term.id}: {error.title}")
+
+
+def test_create_term(created_term):
+    term = created_term
+    assert term.name == "e2e - please delete"
+
+
+def test_update_term(vendor_terms_service, created_term):
+    service = vendor_terms_service
+    update_data = {"name": "e2e - delete me (updated)"}
+    term = service.update(created_term.id, update_data)
+    assert term.name == "e2e - delete me (updated)"
+
+
+def test_get_term(vendor_terms_service, term_id):
+    service = vendor_terms_service
+    term = service.get(term_id)
+    assert term.id == term_id
+
+
+def test_get_term_by_id(vendor_terms_service, term_id):
+    service = vendor_terms_service
+    term = service.get(term_id)
+    assert term.id == term_id
+
+
+def test_iterate_terms(vendor_terms_service, created_term):
+    service = vendor_terms_service
+    terms = list(service.iterate())
+    assert any(term.id == created_term.id for term in terms)
+
+
+def test_filter_terms(vendor_terms_service, term_id):
+    select_fields = ["-description"]
+    filtered_terms = vendor_terms_service.filter(RQLQuery(id=term_id)).select(*select_fields)
+    terms = list(filtered_terms.iterate())
+    assert len(terms) == 1
+    assert terms[0].id == term_id
+
+
+def test_delete_term(vendor_terms_service, created_term):
+    service = vendor_terms_service
+    service.delete(created_term.id)
+    with pytest.raises(MPTAPIError):
+        service.get(created_term.id)

tests/e2e/catalog/product/terms/variants/conftest.py

@@ -0,0 +1,17 @@
+import pytest
+
+
+@pytest.fixture
+def variant_data():
+    return {
+        "name": "e2e - please delete",
+        "description": "Test variant description",
+        "languageCode": "en-gb",
+        "type": "File",
+        "assetUrl": "",
+    }
+
+
+@pytest.fixture
+def variant_id(e2e_config):
+    return e2e_config["catalog.product.terms.variant.id"]

tests/e2e/catalog/product/terms/variants/test_async_variants.py

@@ -0,0 +1,104 @@
+import pytest
+
+from mpt_api_client.exceptions import MPTAPIError
+from mpt_api_client.rql.query_builder import RQLQuery
+
+pytestmark = [pytest.mark.flaky]
+
+
+@pytest.fixture
+def async_vendor_variant_service(async_mpt_vendor, product_id, term_id):
+    return async_mpt_vendor.catalog.products.terms(product_id).variants(term_id)
+
+
+@pytest.fixture
+async def async_created_variant(
+    variant_data,
+    pdf_fd,
+    async_vendor_variant_service,
+):
+    variant = await async_vendor_variant_service.create(variant_data, pdf_fd)
+    yield variant
+    try:
+        await async_vendor_variant_service.delete(variant.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete variant {variant.id}: {error.title}")
+
+
+@pytest.fixture
+async def created_variant_from_url(
+    variant_data,
+    pdf_url,
+    async_vendor_variant_service,
+):
+    variant_data["type"] = "Online"
+    variant_data["assetUrl"] = pdf_url
+    variant = await async_vendor_variant_service.create(variant_data)
+    yield variant
+    try:
+        await async_vendor_variant_service.delete(variant.id)
+    except MPTAPIError as error:
+        print(f"TEARDOWN - Unable to delete variant {variant.id}: {error.title}")
+
+
+def test_create_variant(async_created_variant):
+    variant = async_created_variant
+    assert variant.name == "e2e - please delete"
+
+
+def test_create_variant_from_url(created_variant_from_url, variant_data):
+    assert created_variant_from_url.name == variant_data["name"]
+
+
+async def test_update_variant(
+    async_mpt_vendor, product_id, term_id, async_created_variant, async_vendor_variant_service
+):
+    service = async_vendor_variant_service
+    update_data = {"name": "e2e - delete me (updated)"}
+    variant = await service.update(async_created_variant.id, update_data)
+    assert variant.name == "e2e - delete me (updated)"
+
+
+async def test_get_variant(
+    async_mpt_vendor, product_id, term_id, variant_id, async_vendor_variant_service
+):
+    service = async_vendor_variant_service
+    variant = await service.get(variant_id)
+    assert variant.id == variant_id
+
+
+async def test_get_variant_by_id(
+    async_mpt_vendor, product_id, term_id, variant_id, async_vendor_variant_service
+):
+    service = async_vendor_variant_service
+    variant = await service.get(variant_id)
+    assert variant.id == variant_id
+
+
+async def test_iterate_variants(
+    async_mpt_vendor, product_id, term_id, async_created_variant, async_vendor_variant_service
+):
+    service = async_vendor_variant_service
+    variants = [variant async for variant in service.iterate()]
+    assert any(variant.id == async_created_variant.id for variant in variants)
+
+
+async def test_filter_variants(
+    async_mpt_vendor, product_id, term_id, variant_id, async_vendor_variant_service
+):
+    select_fields = ["-description"]
+    filtered_variants = async_vendor_variant_service.filter(RQLQuery(id=variant_id)).select(
+        *select_fields
+    )
+    variants = [variant async for variant in filtered_variants.iterate()]
+    assert len(variants) == 1
+    assert variants[0].id == variant_id
+
+
+async def test_delete_variant(
+    async_mpt_vendor, product_id, term_id, async_created_variant, async_vendor_variant_service
+):
+    service = async_vendor_variant_service
+    await service.delete(async_created_variant.id)
+    with pytest.raises(MPTAPIError):
+        await service.get(async_created_variant.id)