channel-app 0.0.135__tar.gz → 0.0.137__tar.gz

{channel_app-0.0.135 → channel_app-0.0.137}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: channel_app
-Version: 0.0.135
+Version: 0.0.137
 Summary: Channel app for Sales Channels
 Home-page: https://github.com/akinon/channel_app
 Author: akinonteam

{channel_app-0.0.135 → channel_app-0.0.137}/channel_app/omnitron/commands/orders/addresses.py

@@ -180,7 +180,7 @@ class GetOrCreateAddress(OmnitronCommandInterface):
     def get_country(self, country_code: str) -> Country:
         endpoint = ChannelCountryEndpoint(channel_id=self.integration.channel_id)
 
-        params = {"code__exact": country_code}
+        params = {"code__exact": country_code, "is_active": True}
         countries = endpoint.list(params=params)
         if len(countries) == 1:
             return countries[0]
@@ -200,7 +200,11 @@ class GetOrCreateAddress(OmnitronCommandInterface):
     def get_city(self, country: Country, city_name: str) -> City:
         endpoint = ChannelCityEndpoint(channel_id=self.integration.channel_id)
 
-        params = {"name__exact": city_name, "country": country.pk}
+        params = {
+            "name__iexact": city_name,
+            "country": country.pk,
+            "is_active": True
+        }
         cities = endpoint.list(params=params)
         if len(cities) == 1:
             return cities[0]
@@ -221,7 +225,12 @@ class GetOrCreateAddress(OmnitronCommandInterface):
     def get_township(self, country: Country, city: City, township_name: str) -> Township:
         endpoint = ChannelTownshipEndpoint(channel_id=self.integration.channel_id)
 
-        params = {"name__exact": township_name, "country": country.pk, "city": city.pk}
+        params = {
+            "name__iexact": township_name,
+            "country": country.pk,
+            "city": city.pk,
+            "is_active": True
+        }
         townships = endpoint.list(params=params)
         if len(townships) == 1:
             return townships[0]
@@ -244,8 +253,13 @@ class GetOrCreateAddress(OmnitronCommandInterface):
                      district_name: str) -> District:
         endpoint = ChannelDistrictEndpoint(channel_id=self.integration.channel_id)
 
-        params = {"name__exact": district_name, "country": country.pk, "city": city.pk,
-                  "township": township.pk}
+        params = {
+            "name__exact": district_name,
+            "country": country.pk,
+            "city": city.pk,
+            "township": township.pk,
+            "is_active": True
+        }
         districts = endpoint.list(params=params)
         if len(districts) == 1:
             return districts[0]

{channel_app-0.0.135 → channel_app-0.0.137}/channel_app/omnitron/commands/product_stocks.py

@@ -47,6 +47,9 @@ class GetUpdatedProductStocks(OmnitronCommandInterface):
         return stocks
 
     def get_stocks_with_available(self, stocks: List[ProductStock]):
+        if not stocks:
+            return []
+
         endpoint = ChannelIntegrationActionEndpoint(
             channel_id=self.integration.channel_id)
         stock_integration_actions = endpoint.list(
@@ -167,6 +170,9 @@ class GetInsertedProductStocks(GetUpdatedProductStocks):
     path = "inserts"
 
     def get_stocks_with_available(self, stocks: List[ProductStock]):
+        if not stocks:
+            return []
+
         endpoint = ChannelIntegrationActionEndpoint(
             channel_id=self.integration.channel_id)
         product_ids = [str(stock.product) for stock in stocks]

{channel_app-0.0.135 → channel_app-0.0.137}/channel_app/omnitron/commands/tests/test_products.py

@@ -1,20 +1,31 @@
 from unittest.mock import MagicMock, patch
 from omnisdk.base_client import BaseClient
 from omnisdk.omnitron.endpoints import (
+    ChannelCategoryTreeEndpoint,
     ChannelIntegrationActionEndpoint,
+    ChannelProductCategoryEndpoint,
     ChannelProductEndpoint, 
+    ChannelProductStockEndpoint,
 )
 from omnisdk.omnitron.models import ChannelAttributeConfig
 
-from channel_app.core.commands import OmnitronCommandInterface
 from channel_app.core.tests import BaseTestCaseMixin
 from channel_app.omnitron.commands.products import (
     GetDeletedProducts,
     GetInsertedProducts,
     GetUpdatedProducts,
-    Product, GetMappedProducts, GetProductPrices,
+    Product, 
+    GetMappedProducts, 
+    GetProductPrices, 
+    GetProductStocks, 
+    GetProductCategoryNodes,
+    GetProductCategoryNodesWithIntegrationAction,
+)
+from channel_app.omnitron.constants import (
+    BatchRequestStatus, 
+    ContentType, 
+    FailedReasonType
 )
-from channel_app.omnitron.constants import BatchRequestStatus
 
 
 class TestGetInsertedProducts(BaseTestCaseMixin):
@@ -110,13 +121,15 @@ class TestGetUpdatedProducts(BaseTestCaseMixin):
                 pk=1, 
                 name='test', 
                 failed_reason_type=None, 
-                modified_date='2021-01-01T00:00:00Z'
+                modified_date='2021-01-01T00:00:00Z',
+                integration_action=MagicMock()
             ), 
             Product(
                 pk=2, 
                 name='test2', 
                 failed_reason_type='error', 
-                modified_date='2021-01-01T00:00:00Z'
+                modified_date='2021-01-01T00:00:00Z',
+                integration_action=MagicMock()
             )
         ]
     
@@ -132,7 +145,7 @@ class TestGetUpdatedProducts(BaseTestCaseMixin):
 
     @patch('channel_app.core.clients.OmnitronApiClient')
     @patch.object(BaseClient, 'get_instance')
-    @patch.object(ChannelIntegrationActionEndpoint, '_list')
+    @patch.object(ChannelIntegrationActionEndpoint, 'list')
     def test_get_integration_actions(
         self,
         mock_list,
@@ -156,19 +169,17 @@ class TestGetUpdatedProducts(BaseTestCaseMixin):
                 'object_id': 2,
             }
         ]
-        mock_list.return_value = example_response
 
-        products = self.get_updated_products.get_integration_actions(
-            self.sample_products
-        )
+        with patch.object(
+            ChannelIntegrationActionEndpoint,
+            '__new__',
+            return_value=example_response,
+        ):
+            products = self.get_updated_products.get_integration_actions(
+                self.sample_products
+            )
 
-        for product in products:
-            for key, value \
-                in example_response.json.return_value[product.pk - 1].items():
-                self.assertEqual(
-                    getattr(product.integration_action, key), 
-                    value
-                )
+        self.assertEqual(len(products), 2)
 
     
     def test_get_integration_actions_without_product(self):
@@ -492,3 +503,369 @@ class TestGetProductPrices(BaseTestCaseMixin):
         mock_get_prices.return_value = price_list
         result = self.get_product_prices.get_product_price(products)
         self.assertFalse(hasattr(result[-1], 'productprice'))
+
+
+class TestGetProductPricesWithOutCommit(TestGetProductPrices):
+    pass
+
+
+class TestGetProductStocks(BaseTestCaseMixin):
+    """
+    Test case for GetProductStocks
+    run: python -m unittest channel_app.omnitron.commands.tests.test_products.TestGetProductStocks
+    """
+
+    def setUp(self) -> None:
+        self.get_product_stocks = GetProductStocks(
+            integration=self.mock_integration
+        )
+        self.sample_products = [
+            Product(
+                pk=1,
+                name='test',
+                failed_reason_type=None,
+                productstock=10,
+                modified_date='2021-01-01T00:00:00Z'
+            ),
+            Product(
+                pk=2,
+                name='test2',
+                failed_reason_type='error',
+                productstock=15,
+                modified_date='2021-01-01T00:00:00Z'
+            )
+        ]
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(GetProductStocks, 'get_stocks')
+    def test_get_data(
+        self,
+        mock_get_stocks,
+        mock_get_instance
+    ):
+        mock_get_stocks.return_value = []
+        self.get_product_stocks.objects = self.sample_products
+        result = self.get_product_stocks.get_data()
+        self.assertEqual(len(result), 2)
+
+    @patch.object(GetProductStocks, 'create_batch_objects')
+    @patch.object(GetProductStocks, 'create_integration_actions')
+    @patch.object(GetProductStocks, 'update_batch_request')
+    def test_normalize_response(
+        self,
+        mock_update_batch_request,
+        mock_create_integration_actions,
+        mock_create_batch_objects
+    ):
+        data = self.sample_products
+        response = MagicMock()
+        response.json.return_value = []
+        self.get_product_stocks.failed_object_list = []
+        result = self.get_product_stocks.normalize_response(data, response)
+        self.assertEqual(result, data)
+
+    @patch.object(GetProductStocks, 'create_batch_objects')
+    def test_create_integration_actions(self, mock_create_batch_objects):
+        data = self.sample_products
+        object_list = []
+        self.get_product_stocks.create_integration_actions(data, object_list)
+        self.assertEqual(mock_create_batch_objects.call_count, 1)
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(GetProductStocks, 'get_stocks')
+    def test_get_product_stock(self, mock_get_stocks, mock_get_instance):
+        products = self.sample_products
+        mock_get_stocks.return_value = []
+        result = self.get_product_stocks.get_product_stock(products)
+        self.assertEqual(result, products)
+        self.assertEqual(len(self.get_product_stocks.failed_object_list), 1)
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(GetProductStocks, 'get_stocks')
+    def test_get_product_stock_with_failed_product(
+        self,
+        mock_get_stocks,
+        mock_get_instance
+    ):
+        products = self.sample_products
+        products[1].failed_reason_type = FailedReasonType.channel_app.value
+        mock_get_stocks.return_value = []
+        result = self.get_product_stocks.get_product_stock(products)
+        self.assertEqual(result, products)
+        self.assertEqual(
+            len(self.get_product_stocks.failed_object_list),
+            1
+        )
+        self.assertEqual(
+            self.get_product_stocks.failed_object_list[0][0],
+            products[0]
+        )
+        self.assertEqual(
+            self.get_product_stocks.failed_object_list[0][1],
+            ContentType.product.value
+        )
+        self.assertEqual(
+            self.get_product_stocks.failed_object_list[0][2],
+            "StockNotFound"
+        )
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(GetProductStocks, 'get_stocks')
+    def test_get_product_stock_with_stock_not_found(
+        self,
+        mock_get_stocks,
+        mock_get_instance
+    ):
+        products = self.sample_products
+        mock_get_stocks.return_value = []
+        result = self.get_product_stocks.get_product_stock(products)
+        self.assertEqual(result, products)
+        self.assertEqual(
+            len(self.get_product_stocks.failed_object_list),
+            1
+        )
+        self.assertEqual(
+            self.get_product_stocks.failed_object_list[0][0],
+            products[0]
+        )
+        self.assertEqual(
+            self.get_product_stocks.failed_object_list[0][1],
+            ContentType.product.value
+        )
+        self.assertEqual(
+            self.get_product_stocks.failed_object_list[0][2],
+            "StockNotFound"
+        )
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(ChannelProductStockEndpoint, '_list')
+    def test_get_stocks(self, mock_endpoint, mock_get_instance):
+        example_response = MagicMock()
+        example_response.json.return_value = [
+            {
+                'id': 1,
+                'product': 1,
+                'stock': 1,
+            },
+            {
+                'id': 2,
+                'product': 2,
+                'stock': 1,
+            }
+        ]
+        mock_endpoint.return_value = example_response
+        result = self.get_product_stocks.get_stocks(
+            chunk=["1", "2"],
+            endpoint=ChannelProductStockEndpoint()
+        )
+        self.assertEqual(len(result), 2)
+
+
+class TestGetProductStocksWithOutCommit(TestGetProductStocks):
+    pass
+
+
+class TestGetProductCategoryNodes(BaseTestCaseMixin):
+    """
+    Test case for GetProductCategoryNodes
+    run: python -m unittest channel_app.omnitron.commands.tests.test_products.TestGetProductCategoryNodes
+    """
+
+    def setUp(self) -> None:
+        self.get_product_category_nodes = GetProductCategoryNodes(
+            integration=self.mock_integration
+        )
+        self.sample_products = [
+            Product(pk=1),
+            Product(pk=2)
+        ]
+
+    @patch.object(GetProductCategoryNodes, 'get_product_category')
+    def test_get_data(self, mock_get_product_category):
+        self.get_product_category_nodes.objects = self.sample_products
+        mock_get_product_category.return_value = self.sample_products
+        result = self.get_product_category_nodes.get_data()
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result, self.sample_products)
+        mock_get_product_category.assert_called_once()
+
+    @patch.object(GetProductCategoryNodes, 'create_batch_objects')
+    @patch.object(GetProductCategoryNodes, 'update_batch_request')
+    def test_normalize_response(
+        self,
+        mock_update_batch_request,
+        mock_create_batch_objects
+    ):
+        data = self.sample_products
+        response = MagicMock()
+        self.get_product_category_nodes.failed_object_list = [
+            (
+                self.sample_products[0],
+                ContentType.product.value,
+                "ProductCategoryNotFound"
+            )
+        ]
+        self.get_product_category_nodes.normalize_response(data, response)
+        mock_create_batch_objects.assert_called_once_with(
+            data=[self.sample_products[0]],
+            content_type=ContentType.product.value,
+        )
+        mock_update_batch_request.assert_called_once_with(
+            mock_create_batch_objects.return_value
+        )
+
+    def test_get_product_category(self):
+        products = self.sample_products
+        category_tree_id = 1
+        category_tree = MagicMock()
+        category_tree.category_root = {"path": "/root/category"}
+        category_tree_endpoint = MagicMock()
+        category_tree_endpoint.retrieve.return_value = category_tree
+        product_category_endpoint = MagicMock()
+        product_category_endpoint.list.return_value = [
+            MagicMock(
+                category={
+                    "path": "/root/category/category1"
+                }
+            ),
+            MagicMock(
+                category={
+                    "path": "/root/category/category2"
+                }
+            ),
+        ]
+        product_category_endpoint.iterator = [
+            [MagicMock(
+                category={
+                    "path": "/root/category/category1"
+                }
+            )],
+            [MagicMock(
+                category={
+                    "path": "/root/category/category2"
+                }
+            )],
+        ]
+
+        with patch.object(
+            ChannelCategoryTreeEndpoint,
+            '__new__',
+            return_value=category_tree_endpoint,
+        ), patch.object(
+            ChannelProductCategoryEndpoint,
+            '__new__',
+            return_value=product_category_endpoint,
+        ):
+            self.get_product_category_nodes.get_product_category(products)
+
+        self.assertEqual(len(products), 2)
+        self.assertEqual(
+            self.get_product_category_nodes.failed_object_list,
+            []
+        )
+
+    def test_get_product_category_with_empty_products(self):
+        products = []
+        result = self.get_product_category_nodes.get_product_category(products)
+        self.assertEqual(result, [])
+        self.assertEqual(self.get_product_category_nodes.failed_object_list, [])
+
+
+class TestGetProductCategoryNodesWithIntegrationAction(TestGetProductCategoryNodes):
+    """
+    Test case for GetProductCategoryNodes
+    run: python -m unittest channel_app.omnitron.commands.tests.test_products.TestGetProductCategoryNodesWithIntegrationAction
+    """
+
+    def setUp(self) -> None:
+        self.get_product_category_nodes = GetProductCategoryNodesWithIntegrationAction(
+            integration=self.mock_integration
+        )
+        self.sample_products = [
+            Product(
+                pk=1, 
+                category_nodes=[
+                    {
+                        'pk': 1,
+                        'path': '/root/category/category1'
+                    }
+                ]
+            ),
+            Product(
+                pk=2, 
+                category_nodes=[
+                    {
+                        'pk': 2,
+                        'path': '/root/category/category2'
+                    }
+                ]
+            )
+        ]
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(
+        GetProductCategoryNodesWithIntegrationAction,
+        'get_data'
+    )
+    @patch.object(
+        GetProductCategoryNodesWithIntegrationAction,
+        'get_category_node_integration_action'
+    )
+    def test_get_data(
+        self,
+        mock_get_category_node_integration_action,
+        mock_get_data,
+        mock_get_instance
+    ):
+        self.get_product_category_nodes.objects = self.sample_products
+        mock_get_data.return_value = self.sample_products
+        result = self.get_product_category_nodes.get_data()
+        self.assertEqual(len(result), 2)
+
+    @patch.object(
+        GetProductCategoryNodesWithIntegrationAction,
+        'get_category_node_integration_action'
+    )
+    def test_get_category_node_integration_action(
+        self,
+        mock_get_category_node_integration_action
+    ):
+        mock_get_category_node_integration_action.return_value = None
+        result = self.get_product_category_nodes.get_category_node_integration_action(
+            self.sample_products
+        )
+        self.assertIsNone(result)
+
+    @patch.object(BaseClient, 'get_instance')
+    @patch.object(ChannelIntegrationActionEndpoint, 'list')
+    def test_get_category_node_integration_action_with_products(
+        self,
+        mock_endpoint,
+        mock_get_instance
+    ):
+        integration_action_endpoint = MagicMock()
+        integration_action_endpoint.list.return_value = [
+            MagicMock(
+                channel=1,
+                object_id=1
+            ),
+        ]
+        integration_action_endpoint.iterator = [
+            [MagicMock(
+                channel=1,
+                object_id=1
+            )],
+        ]
+        mock_endpoint.return_value = integration_action_endpoint
+
+        with patch.object(
+            ChannelIntegrationActionEndpoint, 
+            '__new__',
+            return_value=integration_action_endpoint,
+            channel_id=1
+        ):
+            result = self.get_product_category_nodes.get_category_node_integration_action(
+                self.sample_products
+            )
+
+        self.assertEqual(len(result), 2)

{channel_app-0.0.135 → channel_app-0.0.137}/channel_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: channel-app
-Version: 0.0.135
+Version: 0.0.137
 Summary: Channel app for Sales Channels
 Home-page: https://github.com/akinon/channel_app
 Author: akinonteam

{channel_app-0.0.135 → channel_app-0.0.137}/setup.py

@@ -5,7 +5,7 @@ with open("README.md") as f:
 
 setup(
     name="channel_app",
-    version="0.0.135",
+    version="0.0.137",
     packages=find_packages(),
     url="https://github.com/akinon/channel_app",
     description="Channel app for Sales Channels",