producteca 1.0.13__py3-none-any.whl → 2.0.14__py3-none-any.whl

producteca/abstract/abstract_dataclass.py

@@ -1,23 +1,11 @@
-from pydantic import BaseModel, PrivateAttr
-from abc import ABC, abstractmethod
-from ..config.config import ConfigProducteca, APIConfig
+from abc import ABC
+from ..config.config import ConfigProducteca
+from dataclasses import dataclass
+from typing import Optional
 
 
-class AbstractProductecaModel(BaseModel, ABC):
-    _config: APIConfig = PrivateAttr()
-
-    @property
-    @abstractmethod
-    def endpoint(self) -> str:
-        pass
-
-    def dict(self, *args, **kwargs):
-        return super().dict(*args, exclude_none=True, **kwargs)
-
-
-class AbstractProductecaV1Model(AbstractProductecaModel):
-    _config: ConfigProducteca = PrivateAttr()
-
-    @property
-    def endpoint_url(self) -> str:
-        return self._config.get_endpoint(self.endpoint)
+@dataclass
+class BaseService[T](ABC):
+    config: ConfigProducteca
+    endpoint: str
+    _record: Optional[T] = None

producteca/client.py

@@ -1,37 +1,22 @@
 from producteca.config.config import ConfigProducteca
-from producteca.products.products import Product
-from producteca.sales_orders.sales_orders import SalesOrder
-from producteca.search.search import Search
-from producteca.shipments.shipment import Shipment
-from producteca.payments.payments import Payment
+from producteca.products.products import ProductService
+from producteca.sales_orders.sales_orders import SaleOrderService
 import os
 
 
 class ProductecaClient:
 
-    def __init__(self, token: str = os.environ['PRODUCTECA_TOKEN'], api_key: str = os.environ['PRODUCTECA_API_KEY']):
+    def __init__(self, token: str = os.environ.get('PRODUCTECA_TOKEN', ''), api_key: str = os.environ.get('PRODUCTECA_API_KEY', '')):
         if not token:
             raise ValueError('PRODUCTECA_TOKEN environment variable not set')
         if not api_key:
             raise ValueError('PRODUCTECA_API_KEY environment variable not set')
         self.config = ConfigProducteca(token=token, api_key=api_key)
-        
-    @property
-    def Product(self):
-        return lambda *args: Product(config=self.config, *args)
-
-    @property 
-    def SalesOrder(self):
-        return lambda *args: SalesOrder(config=self.config, *args)
 
     @property
-    def Search(self):
-        return lambda *args: Search(config=self.config, *args)
-
-    @property
-    def Shipment(self):
-        return lambda *args: Shipment(config=self.config, *args)
+    def Product(self):
+        return ProductService(self.config)
 
     @property
-    def Payment(self):
-        return lambda *args: Payment(config=self.config, *args)
+    def SalesOrder(self):
+        return SaleOrderService(self.config)

producteca/config/__init__.py

@@ -1 +0,0 @@
-from .config import ConfigProducteca

producteca/payments/payments.py

@@ -1,7 +1,5 @@
 from pydantic import BaseModel
 from typing import Optional
-import requests
-from ..config.config import ConfigProducteca
 
 
 class PaymentCard(BaseModel):
@@ -32,14 +30,4 @@ class Payment(BaseModel):
     hasCancelableStatus: bool
     id: Optional[int] = None
 
-    @classmethod
-    def create(cls, config: ConfigProducteca, sale_order_id: int, payload: "Payment") -> "Payment":
-        url = config.get_endpoint(f"salesorders/{sale_order_id}/payments")
-        res = requests.post(url, data=payload.model_dump_json(exclude_none=True), headers=config.headers)
-        return cls(**res.json())
-
-    @classmethod
-    def update(cls, config: ConfigProducteca, sale_order_id: int, payment_id: int, payload: "Payment") -> "Payment":
-        url = config.get_endpoint(f"salesorders/{sale_order_id}/payments/{payment_id}")
-        res = requests.put(url, data=payload.model_dump_json(exclude_none=True), headers=config.headers)
-        return cls(**res.json())
+

producteca/payments/tests/test_payments.py

@@ -1,13 +1,13 @@
 import unittest
 from unittest.mock import patch, Mock
 from datetime import datetime
-from producteca.config.config import ConfigProducteca
-from producteca.payments.payments import Payment, PaymentCard, PaymentIntegration
+from producteca.client import ProductecaClient
+from producteca.payments.payments import Payment
 
 
 class TestPayments(unittest.TestCase):
     def setUp(self):
-        self.config = ConfigProducteca(token="asd", api_key="test_key")
+        self.client = ProductecaClient(token="asd", api_key="test_key")
         self.sale_order_id = 123
         self.payment_id = 456
         
@@ -35,7 +35,7 @@ class TestPayments(unittest.TestCase):
         payment = Payment(**self.payment_data)
         
         # Test create method
-        result = Payment.create(self.config, self.sale_order_id, payment)
+        result = self.client.SalesOrder(id=self.sale_order_id).add_payment(payment)
         
         # Assertions
         mock_post.assert_called_once()
@@ -55,7 +55,7 @@ class TestPayments(unittest.TestCase):
         payment = Payment(**self.payment_data)
         
         # Test update method
-        result = Payment.update(self.config, self.sale_order_id, self.payment_id, payment)
+        result = self.client.SalesOrder(id=self.sale_order_id).update_payment(self.payment_id, payment)
         
         # Assertions
         mock_put.assert_called_once()

producteca/products/__init__.py

@@ -1 +0,0 @@
-from . import products

producteca/products/products.py

@@ -1,20 +1,23 @@
 from typing import List, Optional, Union
 from pydantic import BaseModel, Field
-import requests
-from ..config.config import ConfigProducteca
+from dataclasses import dataclass
+from producteca.abstract.abstract_dataclass import BaseService
+from producteca.products.search_products import SearchProduct, SearchProductParams
 import logging
+import requests
 
 _logger = logging.getLogger(__name__)
 
-# Models for nested structures
 
 class Attribute(BaseModel):
     key: str
     value: str
 
+
 class Tag(BaseModel):
     tag: str
 
+
 class Dimensions(BaseModel):
     weight: Optional[float] = None
     width: Optional[float] = None
@@ -22,11 +25,13 @@ class Dimensions(BaseModel):
     length: Optional[float] = None
     pieces: Optional[int] = None
 
+
 class Deal(BaseModel):
     campaign: str
     regular_price: Optional[float] = Field(default=None, alias='regularPrice')
     deal_price: Optional[float] = Field(default=None, alias='dealPrice')
 
+
 class Stock(BaseModel):
     quantity: Optional[int] = None
     available_quantity: Optional[int] = Field(default=None, alias='availableQuantity')
@@ -35,15 +40,18 @@ class Stock(BaseModel):
     reserved: Optional[int] = None
     available: Optional[int] = None
 
+
 class Price(BaseModel):
     amount: Optional[float] = None
     currency: str
     price_list: str = Field(alias='priceList')
     price_list_id: Optional[int] = Field(default=None, alias='priceListId')
 
+
 class Picture(BaseModel):
     url: str
 
+
 class Integration(BaseModel):
     app: Optional[int] = None
     integration_id: Optional[str] = Field(default=None, alias='integrationId')
@@ -57,6 +65,7 @@ class Integration(BaseModel):
     id: Optional[int] = None
     parent_integration: Optional[str] = Field(default=None, alias='parentIntegration')
 
+
 class Variation(BaseModel):
     variation_id: Optional[int] = Field(default=None, alias='variationId')
     components: Optional[List] = None
@@ -71,11 +80,15 @@ class Variation(BaseModel):
     sku: Optional[str] = None
     barcode: Optional[str] = None
 
-# Model base para los productos
+
+class MeliCategory(BaseModel):
+    meli_id: Optional[str] = Field(default=None, alias='meliId')
+    accepts_mercadoenvios: Optional[bool] = Field(default=None, alias='acceptsMercadoenvios')
+    suggest: Optional[bool] = None
+    fixed: Optional[bool] = None
+
+
 class Product(BaseModel):
-    config: Optional[ConfigProducteca] = Field(default=None, exclude=True)
-    endpoint: str = Field(default='products', exclude=True)
-    create_if_it_doesnt_exist: bool = Field(default=False, exclude=True)
     sku: Optional[str] = None
     variation_id: Optional[int] = None
     code: Optional[str] = None
@@ -85,7 +98,7 @@ class Product(BaseModel):
     tags: Optional[List[str]] = None
     buying_price: Optional[float] = None
     dimensions: Optional[Dimensions] = None
-    category: Optional[Union[str, dict]] = None  # Puede ser string en POST o dict en GET Meli
+    category: Optional[Union[str, MeliCategory]]
     brand: Optional[str] = None
     notes: Optional[str] = None
     deals: Optional[List[Deal]] = None
@@ -94,60 +107,6 @@ class Product(BaseModel):
     pictures: Optional[List[Picture]] = None
 
 
-    def create(self):
-        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.model_dump_json(by_alias=True, exclude_none=True)
-        response = requests.post(endpoint_url, data=data, headers=headers)
-        if response.status_code == 204:
-            final_response = {"Message":"Product does not exist and the request cant create if it does not exist"}
-        else:
-            final_response = response.json()
-        return final_response, response.status_code
-
-    def update(self):
-        endpoint_url = self.config.get_endpoint(f'{self.endpoint}/synchronize')
-        headers = self.config.headers.copy()
-        data = self.model_dump_json(by_alias=True, exclude_none=True)
-        if not self.code and not self.sku:
-            return {"Message":"Sku or code should be provided to update the product"}, 204
-        response = requests.post(endpoint_url, data=data, headers=headers)
-        if response.status_code == 204:
-            final_response = {"Message":"Product does not exist and the request cant create if it does not exist"}
-        else:
-            final_response = response.json()
-        return final_response, response.status_code
-
-    @classmethod
-    def get(cls, config: ConfigProducteca, product_id: int):
-        endpoint_url = config.get_endpoint(f'{cls().endpoint}/{product_id}')
-        headers = config.headers
-        response = requests.get(endpoint_url, headers=headers)
-        response_data = response.json()
-        return response_data, response.status_code
-
-    @classmethod
-    def get_bundle(cls, config: ConfigProducteca, product_id: int):
-        endpoint_url = config.get_endpoint(f'{cls().endpoint}/{product_id}/bundles')
-        headers = config.headers
-        response = requests.get(endpoint_url, headers=headers)
-        return cls(config=config, **response.json()), response.status_code
-
-    @classmethod
-    def get_ml_integration(cls, config: ConfigProducteca, product_id: int):
-        endpoint_url = config.get_endpoint(f'{cls().endpoint}/{product_id}/listintegration')
-        headers = config.headers
-        response = requests.get(endpoint_url, headers=headers)
-        return cls(config=config, **response.json()), response.status_code
-
-# Modelo con campos extra de la vista Meli
-class MeliCategory(BaseModel):
-    meli_id: Optional[str] = Field(default=None, alias='meliId')
-    accepts_mercadoenvios: Optional[bool] = Field(default=None, alias='acceptsMercadoenvios')
-    suggest: Optional[bool] = None
-    fixed: Optional[bool] = None
-
 class Shipping(BaseModel):
     local_pickup: Optional[bool] = Field(default=None, alias='localPickup')
     mode: Optional[str] = None
@@ -156,9 +115,11 @@ class Shipping(BaseModel):
     mandatory_free_shipping: Optional[bool] = Field(default=None, alias='mandatoryFreeShipping')
     free_shipping_method: Optional[str] = Field(default=None, alias='freeShippingMethod')
 
+
 class MShopsShipping(BaseModel):
     enabled: Optional[bool] = None
 
+
 class AttributeCompletion(BaseModel):
     product_identifier_status: Optional[str] = Field(default=None, alias='productIdentifierStatus')
     data_sheet_status: Optional[str] = Field(default=None, alias='dataSheetStatus')
@@ -166,13 +127,14 @@ class AttributeCompletion(BaseModel):
     count: Optional[int] = None
     total: Optional[int] = None
 
+
 class MeliProduct(Product):
     product_id: Optional[int] = Field(default=None, alias='productId')
     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[MeliCategory] = None
+    category: Optional[Union[str, MeliCategory]]  # will never be str, but needs compat with super class
     attribute_completion: Optional[AttributeCompletion] = Field(default=None, alias='attributeCompletion')
     catalog_products: Optional[List[str]] = Field(default=None, alias='catalogProducts')
     warranty: Optional[str] = None
@@ -180,3 +142,66 @@ class MeliProduct(Product):
     listing_type_id: Optional[str] = Field(default=None, alias='listingTypeId')
     catalog_products_status: Optional[str] = Field(default=None, alias='catalogProductsStatus')
 
+
+@dataclass
+class ProductService(BaseService[Product]):
+    endpoint: str = Field(default='products', exclude=True)
+    create_if_it_doesnt_exist: bool = Field(default=False, exclude=True)
+
+    def __call__(self, **payload):
+        self._record = Product(**payload)
+        return self
+
+    def create(self):
+        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())
+
+    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 response.status_code == 204:
+            raise Exception("Product does not exist and the request cant create if it does not exist")
+        return Product(**response.json())
+
+    def get(self, product_id: int) -> "Product":
+        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)
+
+    def get_bundle(self, product_id: int) -> "Product":
+        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())
+
+    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())
+
+    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))
+        return SearchProduct(**response.json())

producteca/{search/search.py → products/search_products.py}

@@ -1,7 +1,5 @@
 from typing import List, Optional
 from pydantic import BaseModel, Field
-import requests
-from ..config.config import ConfigProducteca
 
 
 class FacetValue(BaseModel):
@@ -124,7 +122,7 @@ class SearchResultItem(BaseModel):
     channel_pictures_templates_apps: Optional[List[str]]
 
 
-class SearchProductResponse(BaseModel):
+class SearchProduct(BaseModel):
     count: int
     facets: List[Facet]
     results: List[SearchResultItem]
@@ -138,12 +136,4 @@ class SearchProductParams(BaseModel):
     sales_channel: Optional[str] = Field(default='2', alias='salesChannel')
 
 
-class SearchProduct:
-    endpoint: str = 'search/products'
 
-    @classmethod
-    def search_product(cls, config: ConfigProducteca, params: SearchProductParams) -> SearchProductResponse:
-        headers = config.headers
-        url = config.get_endpoint(cls.endpoint)
-        response = requests.get(url, headers=headers, params=params.model_dump(by_alias=True, exclude_none=True))
-        return SearchProductResponse(**response.json())

producteca/products/tests/test_products.py

@@ -1,17 +1,17 @@
 import unittest
 from unittest.mock import patch, Mock
-from producteca.config.config import ConfigProducteca
-from producteca.products.products import Product, MeliProduct
+from producteca.products.products import Product
+from producteca.client import ProductecaClient
 
 
 class TestProduct(unittest.TestCase):
     def setUp(self):
-        self.config = ConfigProducteca(token="test_id", api_key="test_secret")
+        self.client = ProductecaClient(token="test_client_id", api_key="test_client_secret")
         self.test_product = Product(
-            config=self.config,
             sku="TEST001",
             name="Test Product",
-            code="TEST001"
+            code="TEST001",
+            category="Test"
         )
 
     @patch('requests.post')
@@ -19,13 +19,12 @@ class TestProduct(unittest.TestCase):
         # Mock successful response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.create()
+        response = self.client.Product(**self.test_product.model_dump()).create()
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["sku"], "TEST001")
+        self.assertEqual(response.sku, "TEST001")
 
     @patch('requests.post')
     def test_create_product_not_exist(self, mock_post):
@@ -34,48 +33,45 @@ class TestProduct(unittest.TestCase):
         mock_response.status_code = 204
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.create()
-        
-        self.assertEqual(status_code, 204)
-        self.assertEqual(response["Message"], "Product does not exist and the request cant create if it does not exist")
+        with self.assertRaises(Exception):
+            self.client.Product.create()
 
     @patch('requests.post')
     def test_update_product_success(self, mock_post):
         # Mock successful update
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"id": 1, "sku": "TEST001", "name": "Updated Product"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_post.return_value = mock_response
 
-        response, status_code = self.test_product.update()
+        response = self.client.Product(**self.test_product.model_dump()).update()
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["name"], "Updated Product")
+        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 = {"id": 1, "sku": "TEST001"}
+        mock_response.json.return_value = self.test_product.model_dump()
         mock_get.return_value = mock_response
 
-        response, status_code = Product.get(self.config, 1)
+        response = self.client.Product.get(1)
         
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["sku"], "TEST001")
+        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
-        mock_response.json.return_value = {"sku": "TEST001", "bundles": []}
+        test_prod = self.test_product.model_dump()
+        test_prod.update({"sku": "TEST001", "bundles": []})
+        mock_response.json.return_value = test_prod
         mock_get.return_value = mock_response
 
-        product, status_code = Product.get_bundle(self.config, 1)
+        product = self.client.Product.get_bundle(1)
         
-        self.assertEqual(status_code, 200)
         self.assertEqual(product.sku, "TEST001")
 
     @patch('requests.get')
@@ -83,13 +79,15 @@ class TestProduct(unittest.TestCase):
         # Mock ML integration response
         mock_response = Mock()
         mock_response.status_code = 200
-        mock_response.json.return_value = {"sku": "TEST001", "integrations": []}
+        test_prod = self.test_product.model_dump()
+        test_prod.update({"sku": "TEST001", "integrations": []})
+        mock_response.json.return_value = test_prod
         mock_get.return_value = mock_response
 
-        product, status_code = Product.get_ml_integration(self.config, 1)
+        product = self.client.Product.get_ml_integration(1)
         
-        self.assertEqual(status_code, 200)
         self.assertEqual(product.sku, "TEST001")
 
+
 if __name__ == '__main__':
     unittest.main()

producteca/{search/tests/test_search.py → products/tests/test_search_products.py}

@@ -1,81 +1,12 @@
 import unittest
 from unittest.mock import patch, Mock
-from producteca.config.config import ConfigProducteca
-from producteca.search.search_sale_orders import SearchSalesOrder, SearchSalesOrderParams, SearchSalesOrderResponse
-from producteca.search.search import SearchProduct, SearchProductParams
-
-class TestSearchSalesOrder(unittest.TestCase):
-    def setUp(self):
-        self.config = ConfigProducteca(
-            token="test_client_id",
-            api_key="test_client_secret",
-        )
-        self.params = SearchSalesOrderParams(
-            top=10,
-            skip=0,
-            filter="status eq 'confirmed'"
-        )
-
-    @patch('requests.get')
-    def test_search_saleorder_success(self, mock_get):
-        # Mock successful response
-        mock_response = Mock()
-        mock_response.json.return_value = {
-            "count": 1,
-            "results": [{
-                "id": "123",
-                "status": "confirmed",
-                "lines": [],
-                "payments": [],
-                "shipments": [],
-                "integrations": [],
-                "codes": [],
-                "integration_ids": [],
-                "product_names": [],
-                "skus": [],
-                "tags": [],
-                "brands": []
-            }]
-        }
-        mock_response.status_code = 200
-        mock_get.return_value = mock_response
-
-        response, status_code = SearchSalesOrder.search_saleorder(self.config, self.params)
-        
-        # Validate response
-        self.assertEqual(status_code, 200)
-        self.assertEqual(response["count"], 1)
-        self.assertEqual(len(response["results"]), 1)
-        self.assertEqual(response["results"][0]["id"], "123")
-
-        # Verify the request was made with correct parameters
-        expected_url = f"{self.config.get_endpoint(SearchSalesOrder.endpoint)}?$filter={self.params.filter}&top={self.params.top}&skip={self.params.skip}"
-        mock_get.assert_called_once_with(
-            expected_url,
-            headers=self.config.headers
-        )
-
-    @patch('requests.get')
-    def test_search_saleorder_error(self, mock_get):
-        # Mock error response
-        mock_response = Mock()
-        mock_response.json.return_value = {"error": "Invalid request"}
-        mock_response.status_code = 400
-        mock_get.return_value = mock_response
-
-        response, status_code = SearchSalesOrder.search_saleorder(self.config, self.params)
-        
-        # Validate error response
-        self.assertEqual(status_code, 400)
-        self.assertEqual(response["error"], "Invalid request")
+from producteca.products.search_products import SearchProductParams
+from producteca.client import ProductecaClient
 
 
 class TestSearchProduct(unittest.TestCase):
     def setUp(self):
-        self.config = ConfigProducteca(
-            token="test_client_id",
-            api_key="test_client_secret",
-        )
+        self.client = ProductecaClient(token="test_client_id", api_key="test_client_secret")
         self.params = SearchProductParams(
             top=10,
             skip=0,
@@ -181,15 +112,13 @@ class TestSearchProduct(unittest.TestCase):
         mock_response.status_code = 200
         mock_get.return_value = mock_response
 
-        response = SearchProduct.search_product(self.config, self.params)
+        response = self.client.Product.search(self.params)
         
         # Validate response
         self.assertEqual(response.count, 1)
         self.assertEqual(len(response.results), 1)
         self.assertEqual(response.results[0].id, 123)
         self.assertEqual(response.results[0].name, "Test Product")
-        
-        
 
     @patch('requests.get')
     def test_search_product_error(self, mock_get):
@@ -200,7 +129,7 @@ class TestSearchProduct(unittest.TestCase):
         mock_get.return_value = mock_response
         # TODO: Fix this
         # with self.assertRaises(Exception):
-        #     SearchProduct.search_product(self.config, self.params)
+        #     self.client.Product.search(self.params)
 
 
 if __name__ == '__main__':

producteca/sales_orders/__init__.py

@@ -1 +0,0 @@
-from . import sales_orders