producteca 2.0.15__tar.gz → 2.0.16__tar.gz

{producteca-2.0.15 → producteca-2.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: producteca
-Version: 2.0.15
+Version: 2.0.16
 Summary: 
 Author: Chroma Agency, Matias Rivera
 Author-email: mrivera@chroma.agency

producteca-2.0.16/producteca/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa
+
+from .client import ProductecaClient

producteca-2.0.16/producteca/abstract/abstract_dataclass.py

@@ -0,0 +1,23 @@
+from abc import ABC
+from ..config.config import ConfigProducteca
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class BaseService[T](ABC):
+    config: ConfigProducteca
+    endpoint: str
+    _record: Optional[T] = None
+    
+    def __repr__(self):
+        return repr(self._record)
+
+    def to_dict(self):
+        return self._record.model_dump(by_alias=True)
+
+    def to_json(self):
+        return self._record.model_dump_json(by_alias=True)
+
+    def __getattr__(self, key):
+        return getattr(self._record, key)

{producteca-2.0.15 → producteca-2.0.16}/producteca/client.py

@@ -1,6 +1,7 @@
 from producteca.config.config import ConfigProducteca
 from producteca.products.products import ProductService
 from producteca.sales_orders.sales_orders import SaleOrderService
+
 import os
 
 
@@ -20,3 +21,4 @@ class ProductecaClient:
     @property
     def SalesOrder(self):
         return SaleOrderService(self.config)
+

{producteca-2.0.15 → producteca-2.0.16}/producteca/payments/tests/test_payments.py

@@ -35,7 +35,15 @@ class TestPayments(unittest.TestCase):
         payment = Payment(**self.payment_data)
         
         # Test create method
-        result = self.client.SalesOrder(id=self.sale_order_id).add_payment(payment)
+        result = self.client.SalesOrder(id=self.sale_order_id, invoiceIntegration={
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }).add_payment(payment.model_dump(by_alias=True))
         
         # Assertions
         mock_post.assert_called_once()
@@ -55,7 +63,15 @@ class TestPayments(unittest.TestCase):
         payment = Payment(**self.payment_data)
         
         # Test update method
-        result = self.client.SalesOrder(id=self.sale_order_id).update_payment(self.payment_id, payment)
+        result = self.client.SalesOrder(id=self.sale_order_id, invoiceIntegration={
+                'id': 1,
+                'integrationId': 'test-integration',
+                'app': 1,
+                'createdAt': '2023-01-01',
+                'decreaseStock': True,
+                "documentUrl": "https://aallala.copm",
+                "xmlUrl": "https://aallala.copm",
+            }).update_payment(self.payment_id, payment.model_dump(by_alias=True))
         
         # Assertions
         mock_put.assert_called_once()

{producteca-2.0.15 → producteca-2.0.16}/producteca/products/products.py

@@ -1,5 +1,5 @@
 from typing import List, Optional, Union
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ValidationError
 from dataclasses import dataclass
 from producteca.abstract.abstract_dataclass import BaseService
 from producteca.products.search_products import SearchProduct, SearchProductParams
@@ -88,23 +88,71 @@ class MeliCategory(BaseModel):
     fixed: Optional[bool] = None
 
 
+class BundleComponent(BaseModel):
+    quantity: int
+    variation_id: int = Field(alias='variationId')
+    product_id: int = Field(alias='productId')
+
+
+class BundleVariation(BaseModel):
+    variation_id: int = Field(alias='variationId')
+    components: List[BundleComponent]
+
+
+class BundleResult(BaseModel):
+    company_id: int = Field(alias='companyId')
+    product_id: int = Field(alias='productId')
+    variations: List[BundleVariation]
+    id: str
+
+
+class BundleResponse(BaseModel):
+    results: List[BundleResult]
+    count: int
+
+
 class Product(BaseModel):
+    integrations: Optional[List[Integration]] = None
+    variations: Optional[List[Variation]] = None
+    is_simple: Optional[bool] = Field(default=None, alias='isSimple')
+    has_variations: Optional[bool] = Field(default=None, alias='hasVariations') 
+    thumbnail: Optional[str] = None
+    category: Optional[str] = None
+    notes: Optional[str] = None
+    prices: Optional[List[Price]] = None
+    buying_price: Optional[float] = Field(default=None, alias='buyingPrice')
+    is_archived: Optional[bool] = Field(default=None, alias='isArchived')
+    dimensions: Optional[Dimensions] = None
+    attributes: Optional[List[Attribute]] = None
+    metadata: Optional[List[str]] = None
+    is_original: Optional[bool] = Field(default=None, alias='isOriginal')
+    name: str
+    code: Optional[str] = None
     sku: Optional[str] = None
-    variation_id: Optional[int] = None
+    brand: Optional[str] = None
+    id: Optional[int] = None
+
+
+class ProductVariationBase(BaseModel):
+    sku: str
+    variation_id: Optional[int] = Field(default=None, alias='variationId')
     code: Optional[str] = None
-    name: Optional[str] = None
     barcode: Optional[str] = None
-    attributes: Optional[List[Attribute]] = None
-    tags: Optional[List[str]] = None
-    buying_price: Optional[float] = None
-    dimensions: Optional[Dimensions] = None
-    category: Optional[Union[str, MeliCategory]]
-    brand: Optional[str] = None
-    notes: Optional[str] = None
-    deals: Optional[List[Deal]] = None
-    stocks: Optional[List[Stock]] = None
-    prices: Optional[List[Price]] = None
-    pictures: Optional[List[Picture]] = None
+    attributes: List[Attribute] = []
+    tags: Optional[List[str]] = []
+    buying_price: Optional[float] = Field(0, alias='buyingPrice')
+    dimensions: Optional[Dimensions] = Field(default_factory=Dimensions)
+    brand: Optional[str] = ''
+    notes: Optional[str] = ''
+    deals: Optional[List[Deal]] = []
+    stocks: List[Stock]
+    prices: Optional[List[Price]] = []
+    pictures: Optional[List[Picture]] = []
+
+
+class ProductVariation(ProductVariationBase):
+    category: Optional[str] = Field(default=None)
+    name: str
 
 
 class Shipping(BaseModel):
@@ -128,13 +176,14 @@ class AttributeCompletion(BaseModel):
     total: Optional[int] = None
 
 
-class MeliProduct(Product):
+class MeliProduct(BaseModel):
     product_id: Optional[int] = Field(default=None, alias='productId')
+    tags: Optional[List[str]] = Field(default=None)
     has_custom_shipping_costs: Optional[bool] = Field(default=None, alias='hasCustomShippingCosts')
     shipping: Optional[Shipping] = None
     mshops_shipping: Optional[MShopsShipping] = Field(default=None, alias='mShopsShipping')
     add_free_shipping_cost_to_price: Optional[bool] = Field(default=None, alias='addFreeShippingCostToPrice')
-    category: Optional[Union[str, MeliCategory]]  # will never be str, but needs compat with super class
+    category: MeliCategory
     attribute_completion: Optional[AttributeCompletion] = Field(default=None, alias='attributeCompletion')
     catalog_products: Optional[List[str]] = Field(default=None, alias='catalogProducts')
     warranty: Optional[str] = None
@@ -143,65 +192,138 @@ class MeliProduct(Product):
     catalog_products_status: Optional[str] = Field(default=None, alias='catalogProductsStatus')
 
 
+class ErrorMessage(BaseModel):
+    en: str
+    es: str
+    pt: str
+
+
+class ErrorReason(BaseModel):
+    code: str
+    error: str
+    message: ErrorMessage
+    data: Optional[dict] = None
+
+
+class ResolvedValue(BaseModel):
+    updated: bool
+
+
+class ResolvedError(BaseModel):
+    resolved: Optional[bool] = None
+    reason: Optional[ErrorReason] = None
+    value: Optional[ResolvedValue] = None
+    statusCode: Optional[int] = None
+
+
+class ErrorContext(BaseModel):
+    _ns_name: str
+    id: int
+    requestId: str
+    tokenAppId: str
+    appId: str
+    bearer: str
+    eventId: str
+
+
+class SynchronizeResponse(BaseModel):
+    product: Optional[ResolvedError] = None
+    variation: Optional[ResolvedError] = None
+    deals: Optional[ResolvedError] = None
+    bundles: Optional[ResolvedError] = None
+    taxes: Optional[ResolvedError] = None
+    meliProductListingIntegrations: Optional[ResolvedError] = None
+    tags: Optional[ResolvedError] = None
+    productIntegrations: Optional[ResolvedError] = None
+    statusCode: Optional[int] = None
+    error_context: Optional[ErrorContext] = Field(None, alias='error@context')
+
+
+class ListedSynchronizeResponse(BaseModel):
+    results: List[SynchronizeResponse]
+
+
 @dataclass
 class ProductService(BaseService[Product]):
-    endpoint: str = Field(default='products', exclude=True)
+    endpoint: str = 'products'
     create_if_it_doesnt_exist: bool = Field(default=False, exclude=True)
 
     def __call__(self, **payload):
         self._record = Product(**payload)
         return self
 
-    def create(self):
+    def synchronize(self, payload) -> Union[Product, SynchronizeResponse]:
+
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/synchronize')
         headers = self.config.headers.copy()
         headers.update({"createifitdoesntexist": str(self.create_if_it_doesnt_exist).lower()})
-        data = self._record.model_dump_json(by_alias=True, exclude_none=True)
-        response = requests.post(endpoint_url, data=data, headers=headers)
-        if response.status_code == 204:
-            raise Exception("Product does not exist and the request cant create if it does not exist")
-        return Product(**response.json())
+        product_variation = ProductVariation(**payload)
+        if not product_variation.code and not product_variation.sku:
+            raise Exception("Sku or code should be provided to update the product")
+        data = product_variation.model_dump(by_alias=True, exclude_none=True)
+        response = requests.post(endpoint_url, json=data, headers=headers)
+        response_data = response.json()
+        try:
+            return Product(**response_data)
+        except ValidationError:
+            pass
+        if isinstance(response_data, list):
+            res = ListedSynchronizeResponse(results=response_data)
+            if any([r.error_context for r in res.results]):
+                raise Exception(f"Errored while updating {res.results[0].error_context} {res.model_dump_json()}")
+            else:
+                return res.results[0]
+        else:
+            try:
+                sync_resp = SynchronizeResponse(**response_data)
+                if sync_resp.error_context:
+                    raise Exception(f"Errored while updating {sync_resp.error_context} - {sync_resp.model_dump_json()}")
+                else:
+                    return sync_resp
+            except ValidationError:
+                try:
+                    error_res = ErrorReason(**response_data)
+                    raise Exception(f"Errored with the following message {error_res.message} - {error_res.model_dump_json()}")
+                except ValidationError:
+                    pass
 
-    def update(self):
-        # TODO: Change name to synchronize
-        endpoint_url = self.config.get_endpoint(f'{self.endpoint}/synchronize')
-        headers = self.config.headers.copy()
-        data = self._record.model_dump_json(by_alias=True, exclude_none=True)
-        if not self._record.code and not self._record.sku:
-            raise "Sku or code should be provided to update the product"
-        response = requests.post(endpoint_url, data=data, headers=headers)
+        if not response.ok:
+            raise Exception(f"Error getting product {product_variation.sku} - {product_variation.code}\n {response.text}")
         if response.status_code == 204:
-            raise Exception("Product does not exist and the request cant create if it does not exist")
-        return Product(**response.json())
+            raise Exception("Status code is 204, meaning nothing was updated or created")
+        raise Exception(f"Unhandled error, check response {response.text}")
 
-    def get(self, product_id: int) -> "Product":
+    def get(self, product_id: int) -> "ProductService":
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}')
         headers = self.config.headers
         response = requests.get(endpoint_url, headers=headers)
         if not response.ok:
             raise Exception(f"Error getting product {product_id}\n {response.text}")
         response_data = response.json()
-        return Product(**response_data)
+        return self(**response_data)
 
-    def get_bundle(self, product_id: int) -> "Product":
+    def get_bundle(self, product_id: int) -> BundleResponse:
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}/bundles')
         headers = self.config.headers
         response = requests.get(endpoint_url, headers=headers)
         if not response.ok:
             raise Exception(f"Error getting bundle {product_id}\n {response.text}")
-        return Product(**response.json())
+        return BundleResponse(**response.json())
 
-    def get_ml_integration(self, product_id: int) -> "MeliProduct":
+    def get_ml_integration(self, product_id: int) -> MeliProduct:
         endpoint_url = self.config.get_endpoint(f'{self.endpoint}/{product_id}/listingintegration')
         headers = self.config.headers
         response = requests.get(endpoint_url, headers=headers)
         if not response.ok:
             raise Exception(f"Error getting ml integration {product_id}\n {response.text}")
-        return MeliProduct(**response.json())
+        response_data = response.json()
+        return MeliProduct(**response_data)
 
     def search(self, params: SearchProductParams) -> SearchProduct:
         endpoint: str = f'search/{self.endpoint}'
         headers = self.config.headers
         url = self.config.get_endpoint(endpoint)
         response = requests.get(url, headers=headers, params=params.model_dump(by_alias=True, exclude_none=True))
+        if not response.ok:
+            raise Exception(f"error in searching products {response.text}")
         return SearchProduct(**response.json())

producteca-2.0.16/producteca/products/search_products.py

@@ -0,0 +1,136 @@
+from typing import List, Optional, Union
+from pydantic import BaseModel, Field
+
+
+class FacetValue(BaseModel):
+    count: int
+    value: Optional[Union[str, bool]] = None
+    label: Union[str, bool]
+
+
+class Facet(BaseModel):
+    key: str
+    value: List[FacetValue]
+    is_collection: Optional[bool] = False
+    translate: bool
+
+
+class SearchStocks(BaseModel):
+    warehouse: str
+    quantity: int
+    reserved: int
+
+
+class SearchPrices(BaseModel):
+    price_list_id: int = Field(..., alias='priceListId')
+    price_list: str = Field(..., alias='priceList') 
+    amount: float
+    currency: str
+
+
+class SearchIntegration(BaseModel):
+    app: Optional[int] = None
+    integration_id: Optional[str] = Field(None, alias='integrationId')
+    permalink: Optional[str] = None
+    status: Optional[str] = None
+    listing_type: Optional[str] = Field(None, alias='listingType')
+    safety_stock: Optional[int] = Field(None, alias='safetyStock')
+    synchronize_stock: Optional[bool] = Field(None, alias='synchronizeStock')
+    is_active: Optional[bool] = Field(None, alias='isActive')
+    is_active_or_paused: Optional[bool] = Field(None, alias='isActiveOrPaused')
+    id: Optional[int] = None
+
+
+class SearchDeals(BaseModel):
+    campaign: str
+    product: int
+    variation: str
+    deal_price: float
+    discount: float
+    regular_price: float
+    enabled: bool
+    currency: str
+    id: str
+
+
+class SearchResultItem(BaseModel):
+    search_score: float = Field(..., alias='@search.score')
+    id: int
+    product_id: int = Field(..., alias='productId')
+    company_id: int = Field(..., alias='companyId')
+    name: str
+    code: str
+    skus: List[str]
+    brand: str
+    category: str
+    thumbnail: str
+    stocks: List[SearchStocks]
+    warehouses_with_stock: List[str] = Field(..., alias='warehousesWithStock')
+    total_stock: int = Field(..., alias='totalStock')
+    has_pictures: bool = Field(..., alias='hasPictures')
+    buying_price: float = Field(..., alias='buyingPrice')
+    prices: List[SearchPrices]
+    integration_ids: List[str] = Field(..., alias='integrationIds')
+    integration_apps: List[str] = Field(..., alias='integrationApps')
+    integrations: List[SearchIntegration]
+    campaigns: List[str]
+    app: Optional[int] = None
+    status: Optional[str] = None
+    synchronize_stock: Optional[bool] = Field(None, alias='synchronizeStock')
+    listing_type: Optional[str] = Field(None, alias='listingType')
+    price_amount: Optional[float] = Field(None, alias='priceAmount')
+    price_currency: Optional[str] = Field(None, alias='priceCurrency')
+    category_id: Optional[str] = Field(None, alias='categoryId')
+    category_base_id: Optional[str] = Field(None, alias='categoryBaseId')
+    category_l1: Optional[str] = Field(None, alias='categoryL1')
+    category_l2: Optional[str] = Field(None, alias='categoryL2')
+    category_l3: Optional[str] = Field(None, alias='categoryL3')
+    category_l4: Optional[str] = Field(None, alias='categoryL4')
+    category_l5: Optional[str] = Field(None, alias='categoryL5')
+    category_l6: Optional[str] = Field(None, alias='categoryL6')
+    has_category: Optional[bool] = Field(None, alias='hasCategory')
+    category_fixed: Optional[bool] = Field(None, alias='categoryFixed')
+    accepts_mercadoenvios: Optional[bool] = Field(None, alias='acceptsMercadoenvios')
+    shipping_mode: Optional[str] = Field(None, alias='shippingMode')
+    local_pickup: Optional[bool] = Field(None, alias='localPickup')
+    mandatory_free_shipping: Optional[bool] = Field(None, alias='mandatoryFreeShipping')
+    free_shipping: Optional[bool] = Field(None, alias='freeShipping')
+    free_shipping_cost: Optional[float] = Field(None, alias='freeShippingCost')
+    template: Optional[str] = None
+    youtube_id: Optional[str] = Field(None, alias='youtubeId')
+    warranty: Optional[str] = None
+    permalink: Optional[str] = None
+    domain: Optional[str] = None
+    attribute_completion_status: Optional[str] = Field(None, alias='attributeCompletionStatus')
+    attribute_completion_count: Optional[int] = Field(None, alias='attributeCompletionCount')
+    attribute_completion_total: Optional[int] = Field(None, alias='attributeCompletionTotal')
+    deals: Optional[SearchDeals] = None
+    campaign_status: Optional[List[str]] = Field(None, alias='campaignStatus')
+    size_chart: Optional[str] = Field(None, alias='sizeChart')
+    channel_status: Optional[List[str]] = Field(None, alias='channelStatus')
+    channel_category_l1: Optional[List[str]] = Field(None, alias='channelCategoryL1')
+    channel_category_l2: Optional[List[str]] = Field(None, alias='channelCategoryL2')
+    channel_category_l3: Optional[List[str]] = Field(None, alias='channelCategoryL3')
+    channel_category_id: Optional[List[str]] = Field(None, alias='channelCategoryId')
+    channel_synchronizes_stock: Optional[List[str]] = Field(None, alias='channelSynchronizesStock')
+    channel_has_category: Optional[List[str]] = Field(None, alias='channelHasCategory')
+    catalog_products_status: Optional[List[str]] = Field(None, alias='catalogProductsStatus')
+    metadata: Optional[List[str]] = None
+    integration_tags: Optional[List[str]] = Field(None, alias='integrationTags')
+    variations_integration_ids: Optional[List[str]] = Field(None, alias='variationsIntegrationIds')
+    channel_pictures_templates: Optional[List[str]] = Field(None, alias='channelPicturesTemplates')
+    channel_pictures_templates_apps: Optional[List[str]] = Field(None, alias='channelPicturesTemplatesApps')
+
+
+class SearchProduct(BaseModel):
+    count: int
+    facets: List[Facet]
+    results: List[SearchResultItem]
+
+
+class SearchProductParams(BaseModel):
+    top: Optional[int]
+    skip: Optional[int]
+    filter: Optional[str] = Field(default=None, alias='$filter')
+    search: Optional[str] = Field(default=None)
+    sales_channel: Optional[str] = Field(default='2', alias='salesChannel')

producteca-2.0.16/producteca/products/tests/test_products.py

@@ -0,0 +1,178 @@
+import unittest
+from unittest.mock import patch, Mock
+from producteca.products.products import Product
+from producteca.client import ProductecaClient
+
+
+class TestProduct(unittest.TestCase):
+    def setUp(self):
+        self.client = ProductecaClient(token="test_client_id", api_key="test_client_secret")
+        self.test_product = Product(
+            sku="TEST001",
+            name="Test Product",
+            code="TEST001",
+            category="Test"
+        )
+        self.product_to_create_payload = {
+            "sku": "9817234",
+            "code": "871234",
+            "name": "Hola test",
+            "buyingPrice": 0,
+            "deals": [
+                {
+                "campaign": "string",
+                "regularPrice": 0,
+                "dealPrice": 0
+                }
+            ],
+                "prices": [
+                {
+                "amount": 10,
+                "currency": "Local",
+                "priceList": "Default"
+                }
+            ],
+                "stocks": [
+                    {
+                    "quantity": 2,
+                    "availableQuantity": 2,
+                    "warehouse": "Default"
+                    }
+                ],
+            }
+
+    @patch('requests.post')
+    def test_create_product_success(self, mock_post):
+        # Mock successful response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = self.test_product.model_dump()
+        mock_post.return_value = mock_response
+
+        response = self.client.Product(**self.test_product.model_dump()).synchronize(self.product_to_create_payload)
+        
+        self.assertEqual(response.sku, "TEST001")
+
+    @patch('requests.post')
+    def test_create_product_not_exist(self, mock_post):
+        # Mock product not found response
+        mock_response = Mock()
+        mock_response.status_code = 204
+        mock_post.return_value = mock_response
+
+        with self.assertRaises(Exception):
+            self.client.Product.synchronize(self.product_to_create_payload)
+
+    @patch('requests.post')
+    def test_update_product_success(self, mock_post):
+        payload = self.product_to_create_payload
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = self.test_product.model_dump()
+        mock_post.return_value = mock_response
+
+        response = self.client.Product(**self.test_product.model_dump()).synchronize(payload)
+        
+        self.assertEqual(response.name, "Test Product")
+
+    @patch('requests.get')
+    def test_get_product(self, mock_get):
+        # Mock get product response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = self.test_product.model_dump()
+        mock_get.return_value = mock_response
+
+        response = self.client.Product.get(1)
+        
+        self.assertEqual(response.sku, "TEST001")
+
+    @patch('requests.get')
+    def test_get_bundle(self, mock_get):
+        # Mock get bundle response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        test_prod = {
+                "results": [
+                    {
+                    "companyId": 0,
+                    "productId": 0,
+                    "variations": [
+                        {
+                        "variationId": 0,
+                        "components": [
+                            {
+                            "quantity": 0,
+                            "variationId": 0,
+                            "productId": 0
+                            }
+                        ]
+                        }
+                    ],
+                    "id": "string"
+                    }
+                ],
+                "count": 0
+                }
+        mock_response.json.return_value = test_prod
+        mock_get.return_value = mock_response
+
+        product = self.client.Product.get_bundle(1)
+        
+        self.assertEqual(product.count, 0)
+
+    @patch('requests.get')
+    def test_get_ml_integration(self, mock_get):
+        # Mock ML integration response
+        mock_response = Mock()
+        mock_response.status_code = 200
+        meli_product = {
+            "hasCustomShippingCosts": True,
+            "productId": 0,
+            "shipping": {
+                "localPickup": True,
+                "mode": "string",
+                "freeShipping": True,
+                "freeShippingCost": 0,
+                "mandatoryFreeShipping": True,
+                "freeShippingMethod": "string"
+            },
+            "mShopsShipping": {
+                "enabled": True
+            },
+            "addFreeShippingCostToPrice": True,
+            "category": {
+                "meliId": "string",
+                "acceptsMercadoenvios": True,
+                "suggest": True,
+                "fixed": True
+            },
+            "attributeCompletion": {
+                "productIdentifierStatus": "Complete",
+                "dataSheetStatus": "Complete",
+                "status": "Complete",
+                "count": 0,
+                "total": 0
+            },
+            "catalogProducts": [
+                "string"
+            ],
+            "warranty": "string",
+            "domain": "string",
+            "listingTypeId": "GoldSpecial",
+            "catalogProductsStatus": "Unlinked",
+            "tags": [
+                "string"
+            ]
+            }
+        
+        mock_response.json.return_value = meli_product
+        mock_get.return_value = mock_response
+
+        product = self.client.Product.get_ml_integration(1)
+        
+        self.assertEqual(product.listing_type_id, "GoldSpecial")
+
+
+if __name__ == '__main__':
+    unittest.main()