diff --git a/mpt_api_client/resources/catalog/products.py b/mpt_api_client/resources/catalog/products.py index 70920188..3c80002c 100644 --- a/mpt_api_client/resources/catalog/products.py +++ b/mpt_api_client/resources/catalog/products.py @@ -15,6 +15,10 @@ AsyncParameterGroupsService, ParameterGroupsService, ) +from mpt_api_client.resources.catalog.products_parameters import ( + AsyncParametersService, + ParametersService, +) class Product(Model): @@ -45,6 +49,12 @@ def parameter_groups(self, product_id: str) -> ParameterGroupsService: http_client=self.http_client, endpoint_params={"product_id": product_id} ) + def product_parameters(self, product_id: str) -> ParametersService: + """Return product_parameters service.""" + return ParametersService( + http_client=self.http_client, endpoint_params={"product_id": product_id} + ) + class AsyncProductsService( AsyncCreateMixin[Product], @@ -61,3 +71,9 @@ def parameter_groups(self, product_id: str) -> AsyncParameterGroupsService: return AsyncParameterGroupsService( http_client=self.http_client, endpoint_params={"product_id": product_id} ) + + def product_parameters(self, product_id: str) -> AsyncParametersService: + """Return product_parameters service.""" + return AsyncParametersService( + http_client=self.http_client, endpoint_params={"product_id": product_id} + ) diff --git a/mpt_api_client/resources/catalog/products_parameters.py b/mpt_api_client/resources/catalog/products_parameters.py new file mode 100644 index 00000000..1a60b840 --- /dev/null +++ b/mpt_api_client/resources/catalog/products_parameters.py @@ -0,0 +1,40 @@ +from mpt_api_client.http import AsyncService, CreateMixin, DeleteMixin, Service +from mpt_api_client.http.mixins import ( + AsyncCreateMixin, + AsyncDeleteMixin, + AsyncUpdateMixin, + UpdateMixin, +) +from mpt_api_client.models import Model + + +class Parameter(Model): + """Parameter resource.""" + + +class ParametersServiceConfig: + """Parameters service configuration.""" + + _endpoint = "/public/v1/catalog/products/{product_id}/parameters" + _model_class = Parameter + _collection_key = "data" + + +class ParametersService( + CreateMixin[Parameter], + DeleteMixin, + UpdateMixin[Parameter], + Service[Parameter], + ParametersServiceConfig, +): + """Parameters service.""" + + +class AsyncParametersService( + AsyncCreateMixin[Parameter], + AsyncDeleteMixin, + AsyncUpdateMixin[Parameter], + AsyncService[Parameter], + ParametersServiceConfig, +): + """Parameters service.""" diff --git a/setup.cfg b/setup.cfg index 827332d1..9e49df6c 100644 --- a/setup.cfg +++ b/setup.cfg @@ -36,6 +36,7 @@ per-file-ignores = mpt_api_client/resources/catalog/products.py: WPS215 mpt_api_client/resources/catalog/items.py: WPS215 mpt_api_client/resources/catalog/products_parameter_groups.py: WPS215 + mpt_api_client/resources/catalog/products_parameters.py: WPS215 tests/http/test_async_service.py: WPS204 WPS202 tests/http/test_service.py: WPS204 WPS202 diff --git a/tests/resources/catalog/test_catalog.py b/tests/resources/catalog/test_catalog.py index 62d7e89b..06212d41 100644 --- a/tests/resources/catalog/test_catalog.py +++ b/tests/resources/catalog/test_catalog.py @@ -1,5 +1,3 @@ -from typing import Any - import pytest from mpt_api_client.resources.catalog.catalog import AsyncCatalog, Catalog @@ -8,12 +6,12 @@ @pytest.fixture -def catalog(http_client: Any) -> Catalog: +def catalog(http_client): return Catalog(http_client=http_client) @pytest.fixture -def async_catalog(async_http_client: Any) -> AsyncCatalog: +def async_catalog(async_http_client): return AsyncCatalog(http_client=async_http_client) @@ -24,9 +22,7 @@ def async_catalog(async_http_client: Any) -> AsyncCatalog: ("items", ItemsService), ], ) -def test_catalog_properties( - catalog: Catalog, property_name: str, expected_service_class: type -) -> None: +def test_catalog_properties(catalog, property_name, expected_service_class): """Test that Catalog properties return correct instances.""" service = getattr(catalog, property_name) @@ -41,9 +37,7 @@ def test_catalog_properties( ("items", AsyncItemsService), ], ) -def test_async_catalog_properties( - async_catalog: AsyncCatalog, property_name: str, expected_service_class: type -) -> None: +def test_async_catalog_properties(async_catalog, property_name, expected_service_class): """Test that AsyncCatalog properties return correct instances.""" service = getattr(async_catalog, property_name) @@ -51,7 +45,7 @@ def test_async_catalog_properties( assert service.http_client is async_catalog.http_client -def test_catalog_initialization(http_client: Any) -> None: +def test_catalog_initialization(http_client): """Test that Catalog can be properly initialized with http_client.""" catalog = Catalog(http_client=http_client) @@ -59,7 +53,7 @@ def test_catalog_initialization(http_client: Any) -> None: assert isinstance(catalog, Catalog) -def test_async_catalog_initialization(async_http_client: Any) -> None: +def test_async_catalog_initialization(async_http_client): """Test that AsyncCatalog can be properly initialized with http_client.""" async_catalog = AsyncCatalog(http_client=async_http_client) diff --git a/tests/resources/catalog/test_items.py b/tests/resources/catalog/test_items.py index 41119463..cb5ed98c 100644 --- a/tests/resources/catalog/test_items.py +++ b/tests/resources/catalog/test_items.py @@ -1,29 +1,27 @@ -from typing import Any - import pytest from mpt_api_client.resources.catalog.items import AsyncItemsService, ItemsService @pytest.fixture -def items_service(http_client: Any) -> ItemsService: +def items_service(http_client): return ItemsService(http_client=http_client) @pytest.fixture -def async_items_service(async_http_client: Any) -> AsyncItemsService: +def async_items_service(async_http_client): return AsyncItemsService(http_client=async_http_client) @pytest.mark.parametrize( "method", ["get", "create", "update", "delete", "review", "publish", "unpublish"] ) -def test_mixins_present(items_service: ItemsService, method: str) -> None: +def test_mixins_present(items_service, method): assert hasattr(items_service, method) @pytest.mark.parametrize( "method", ["get", "create", "update", "delete", "review", "publish", "unpublish"] ) -def test_async_mixins_present(async_items_service: AsyncItemsService, method: str) -> None: +def test_async_mixins_present(async_items_service, method): assert hasattr(async_items_service, method) diff --git a/tests/resources/catalog/test_products.py b/tests/resources/catalog/test_products.py index 882727b8..7746fe96 100644 --- a/tests/resources/catalog/test_products.py +++ b/tests/resources/catalog/test_products.py @@ -5,6 +5,10 @@ AsyncParameterGroupsService, ParameterGroupsService, ) +from mpt_api_client.resources.catalog.products_parameters import ( + AsyncParametersService, + ParametersService, +) @pytest.fixture @@ -31,15 +35,29 @@ def test_async_mixins_present(async_products_service, method): assert hasattr(async_products_service, method) -def test_parameters_groups_service(products_service): - parameters_groups_service = products_service.parameter_groups("PRD-001") +@pytest.mark.parametrize( + ("service_method", "expected_service_class"), + [ + ("parameter_groups", ParameterGroupsService), + ("product_parameters", ParametersService), + ], +) +def test_property_services(products_service, service_method, expected_service_class): + property_service = getattr(products_service, service_method)("PRD-001") - assert isinstance(parameters_groups_service, ParameterGroupsService) - assert parameters_groups_service.endpoint_params == {"product_id": "PRD-001"} + assert isinstance(property_service, expected_service_class) + assert property_service.endpoint_params == {"product_id": "PRD-001"} -def test_async_parameters_groups_service(async_products_service): - parameters_groups_service = async_products_service.parameter_groups("PRD-001") +@pytest.mark.parametrize( + ("service_method", "expected_service_class"), + [ + ("parameter_groups", AsyncParameterGroupsService), + ("product_parameters", AsyncParametersService), + ], +) +def test_async_property_services(async_products_service, service_method, expected_service_class): + property_service = getattr(async_products_service, service_method)("PRD-001") - assert isinstance(parameters_groups_service, AsyncParameterGroupsService) - assert parameters_groups_service.endpoint_params == {"product_id": "PRD-001"} + assert isinstance(property_service, expected_service_class) + assert property_service.endpoint_params == {"product_id": "PRD-001"} diff --git a/tests/resources/catalog/test_products_parameter_groups.py b/tests/resources/catalog/test_products_parameter_groups.py index 75e0af3a..7382fb65 100644 --- a/tests/resources/catalog/test_products_parameter_groups.py +++ b/tests/resources/catalog/test_products_parameter_groups.py @@ -1,5 +1,3 @@ -from typing import Any - import pytest from mpt_api_client.resources.catalog.products_parameter_groups import ( @@ -9,14 +7,14 @@ @pytest.fixture -def parameter_groups_service(http_client: Any) -> ParameterGroupsService: +def parameter_groups_service(http_client): return ParameterGroupsService( http_client=http_client, endpoint_params={"product_id": "PRD-001"} ) @pytest.fixture -def async_parameter_groups_service(async_http_client: Any) -> AsyncParameterGroupsService: +def async_parameter_groups_service(async_http_client): return AsyncParameterGroupsService( http_client=async_http_client, endpoint_params={"product_id": "PRD-001"} ) diff --git a/tests/resources/catalog/test_products_parameters.py b/tests/resources/catalog/test_products_parameters.py new file mode 100644 index 00000000..4bf3a003 --- /dev/null +++ b/tests/resources/catalog/test_products_parameters.py @@ -0,0 +1,36 @@ +import pytest + +from mpt_api_client.resources.catalog.products_parameters import ( + AsyncParametersService, + ParametersService, +) + + +@pytest.fixture +def parameters_service(http_client): + return ParametersService(http_client=http_client, endpoint_params={"product_id": "PRD-001"}) + + +@pytest.fixture +def async_parameters_service(async_http_client): + return AsyncParametersService( + http_client=async_http_client, endpoint_params={"product_id": "PRD-001"} + ) + + +def test_endpoint(parameters_service): + assert parameters_service.endpoint == "/public/v1/catalog/products/PRD-001/parameters" + + +def test_async_endpoint(async_parameters_service): + assert async_parameters_service.endpoint == "/public/v1/catalog/products/PRD-001/parameters" + + +@pytest.mark.parametrize("method", ["get", "create", "delete", "update"]) +def test_methods_present(parameters_service, method): + assert hasattr(parameters_service, method) + + +@pytest.mark.parametrize("method", ["get", "create", "delete", "update"]) +def test_async_methods_present(async_parameters_service, method): + assert hasattr(async_parameters_service, method)