Contentstack 2.0.1__tar.gz → 2.2.0__tar.gz

{contentstack-2.0.1 → contentstack-2.2.0}/Contentstack.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Contentstack
-Version: 2.0.1
+Version: 2.2.0
 Summary: Contentstack is a headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-python
 Author: Contentstack

{contentstack-2.0.1 → contentstack-2.2.0}/Contentstack.egg-info/SOURCES.txt

@@ -16,13 +16,18 @@ contentstack/controller.py
 contentstack/deep_merge_lp.py
 contentstack/entry.py
 contentstack/entryqueryable.py
+contentstack/globalfields.py
 contentstack/https_connection.py
 contentstack/image_transform.py
 contentstack/query.py
 contentstack/stack.py
 contentstack/utility.py
+contentstack/variants.py
 tests/test_assets.py
+tests/test_early_fetch.py
+tests/test_early_find.py
 tests/test_entry.py
+tests/test_global_fields.py
 tests/test_live_preview.py
 tests/test_query.py
 tests/test_stack.py

{contentstack-2.0.1 → contentstack-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Contentstack
-Version: 2.0.1
+Version: 2.2.0
 Summary: Contentstack is a headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-python
 Author: Contentstack

{contentstack-2.0.1 → contentstack-2.2.0}/contentstack/__init__.py

@@ -22,7 +22,7 @@ __all__ = (
 __title__ = 'contentstack-delivery-python'
 __author__ = 'contentstack'
 __status__ = 'debug'
-__version__ = 'v2.0.1'
+__version__ = 'v2.2.0'
 __endpoint__ = 'cdn.contentstack.io'
 __email__ = 'support@contentstack.com'
 __developer_email__ = 'mobile@contentstack.com'

{contentstack-2.0.1 → contentstack-2.2.0}/contentstack/contenttype.py

@@ -13,6 +13,7 @@ from urllib import parse
 
 from contentstack.entry import Entry
 from contentstack.query import Query
+from contentstack.variants import Variants
 
 class ContentType:
     """
@@ -118,3 +119,18 @@ class ContentType:
         url = f'{endpoint}/content_types?{encoded_params}'
         result = self.http_instance.get(url)
         return result
+    
+    def variants(self, variant_uid: str | list[str], params: dict = None):
+        """
+        Fetches the variants of the content type
+        :param variant_uid: {str} -- variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        return Variants(
+            http_instance=self.http_instance,
+            content_type_uid=self.__content_type_uid,
+            entry_uid=None,
+            variant_uid=variant_uid,
+            params=params,
+            logger=None
+        )

{contentstack-2.0.1 → contentstack-2.2.0}/contentstack/entry.py

@@ -8,6 +8,7 @@ from urllib import parse
 
 from contentstack.deep_merge_lp import DeepMergeMixin
 from contentstack.entryqueryable import EntryQueryable
+from contentstack.variants import Variants
 
 class Entry(EntryQueryable):
     """
@@ -222,6 +223,22 @@ class Entry(EntryQueryable):
             merged_response = DeepMergeMixin(entry_response, lp_entry).to_dict()  # Convert to dictionary
             return merged_response  # Now correctly returns a dictionary
         raise ValueError("Missing required keys in live_preview data")
+    
+    def variants(self, variant_uid: str | list[str], params: dict = None):
+        """
+        Fetches the variants of the entry
+        :param variant_uid: {str} -- variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        return Variants(
+            http_instance=self.http_instance,
+            content_type_uid=self.content_type_id,
+            entry_uid=self.entry_uid,
+            variant_uid=variant_uid,
+            params=params,
+            logger=self.logger
+        )
+
 
 
 

contentstack-2.2.0/contentstack/globalfields.py

@@ -0,0 +1,73 @@
+"""
+Global field defines the structure or schema of a page or a section of your web
+or mobile property. To create content for your application, you are required
+to first create a Global field, and then create entries using the
+Global field.
+"""
+
+import logging
+from urllib import parse
+
+class GlobalField:
+    """
+    Global field defines the structure or schema of a page or a
+    section of your web or mobile property. To create
+    content for your application, you are required to
+    first create a Global field, and then create entries using the
+    Global field.
+    """
+
+    def __init__(self, http_instance, global_field_uid, logger=None):
+        self.http_instance = http_instance
+        self.__global_field_uid = global_field_uid
+        self.local_param = {}
+        self.logger = logger or logging.getLogger(__name__)
+
+
+    def fetch(self):
+        """
+        This method is useful to fetch GlobalField of the of the stack.
+        :return:dict -- GlobalField response
+        ------------------------------
+        Example:
+
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> global_field = stack.global_field('global_field_uid')
+            >>> some_dict = {'abc':'something'}
+            >>> response = global_field.fetch(some_dict)
+        ------------------------------
+        """
+        if self.__global_field_uid is None:
+            raise KeyError(
+                'global_field_uid can not be None to fetch GlobalField')
+        self.local_param['environment'] = self.http_instance.headers['environment']
+        uri = f'{self.http_instance.endpoint}/global_fields/{self.__global_field_uid}'
+        encoded_params = parse.urlencode(self.local_param)
+        url = f'{uri}?{encoded_params}'
+        result = self.http_instance.get(url)
+        return result
+
+    def find(self, params=None):
+        """
+        This method is useful to fetch GlobalField of the of the stack.
+        :param params: dictionary of params
+        :return:dict -- GlobalField response
+        ------------------------------
+        Example:
+
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> global_field = stack.global_field()
+            >>> some_dict = {'abc':'something'}
+            >>> response = global_field.find(param=some_dict)
+        ------------------------------
+        """
+        self.local_param['environment'] = self.http_instance.headers['environment']
+        if params is not None:
+            self.local_param.update(params)
+        encoded_params = parse.urlencode(self.local_param)
+        endpoint = self.http_instance.endpoint
+        url = f'{endpoint}/global_fields?{encoded_params}'
+        result = self.http_instance.get(url)
+        return result

{contentstack-2.0.1 → contentstack-2.2.0}/contentstack/stack.py

@@ -6,6 +6,7 @@ from urllib3.util import Retry
 from contentstack.asset import Asset
 from contentstack.assetquery import AssetQuery
 from contentstack.contenttype import ContentType
+from contentstack.globalfields import GlobalField
 from contentstack.https_connection import HTTPSConnection
 from contentstack.image_transform import ImageTransform
 
@@ -202,6 +203,15 @@ class Stack:
         :return: ContentType
         """
         return ContentType(self.http_instance, content_type_uid)
+    
+    def global_field(self, global_field_uid=None):
+        """
+        Global field defines the structure or schema of a page or a section
+        of your web or mobile property.
+        param global_field_uid:
+        :return: GlobalField
+        """
+        return GlobalField(self.http_instance, global_field_uid)
 
     def asset(self, uid):
         """

contentstack-2.2.0/contentstack/variants.py

@@ -0,0 +1,93 @@
+import logging
+from urllib import parse
+
+from contentstack.entryqueryable import EntryQueryable
+
+class Variants(EntryQueryable):
+    """
+    An entry is the actual piece of content that you want to publish.
+    Entries can be created for one of the available content types.
+
+    Entry works with
+    version={version_number}
+    environment={environment_name}
+    locale={locale_code}
+    """
+
+    def __init__(self,
+        http_instance=None,
+        content_type_uid=None,
+        entry_uid=None,
+        variant_uid=None,
+        params=None,
+        logger=None):
+        
+        super().__init__()
+        EntryQueryable.__init__(self)
+        self.entry_param = {}
+        self.http_instance = http_instance
+        self.content_type_id = content_type_uid
+        self.entry_uid = entry_uid
+        self.variant_uid = variant_uid
+        self.logger = logger or logging.getLogger(__name__)
+        self.entry_param = params or {}
+
+    def find(self, params=None):
+        """
+        find the variants of the entry of a particular content type
+        :param self.variant_uid: {str} -- self.variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        headers = self.http_instance.headers.copy()  # Create a local copy of headers
+        if isinstance(self.variant_uid, str):
+            headers['x-cs-variant-uid'] = self.variant_uid
+        elif isinstance(self.variant_uid, list):
+            headers['x-cs-variant-uid'] = ','.join(self.variant_uid)
+        
+        if params is not None:
+            self.entry_param.update(params)
+        encoded_params = parse.urlencode(self.entry_param)
+        endpoint = self.http_instance.endpoint
+        url = f'{endpoint}/content_types/{self.content_type_id}/entries?{encoded_params}'
+        self.http_instance.headers.update(headers)
+        result = self.http_instance.get(url)
+        self.http_instance.headers.pop('x-cs-variant-uid', None)
+        return result
+    
+    def fetch(self, params=None):
+        """
+        This method is useful to fetch variant entries of a particular content type and entries of the of the stack.
+        :return:dict -- contentType response
+        ------------------------------
+        Example:
+
+            >>> import contentstack
+            >>> stack = contentstack.Stack('api_key', 'delivery_token', 'environment')
+            >>> content_type = stack.content_type('content_type_uid')
+            >>> some_dict = {'abc':'something'}
+            >>> response = content_type.fetch(some_dict)
+        ------------------------------
+        """
+        """
+        Fetches the variants of the entry
+        :param self.variant_uid: {str} -- self.variant_uid
+        :return: Entry, so you can chain this call.
+        """
+        if self.entry_uid is None:
+            raise ValueError("entry_uid is required")
+        else:
+            headers = self.http_instance.headers.copy()  # Create a local copy of headers
+            if isinstance(self.variant_uid, str):
+                headers['x-cs-variant-uid'] = self.variant_uid
+            elif isinstance(self.variant_uid, list):
+                headers['x-cs-variant-uid'] = ','.join(self.variant_uid)
+            
+            if params is not None:
+                self.entry_param.update(params)
+            encoded_params = parse.urlencode(self.entry_param)
+            endpoint = self.http_instance.endpoint
+            url = f'{endpoint}/content_types/{self.content_type_id}/entries/{self.entry_uid}?{encoded_params}'
+            self.http_instance.headers.update(headers)
+            result = self.http_instance.get(url)
+            self.http_instance.headers.pop('x-cs-variant-uid', None)
+            return result

contentstack-2.2.0/tests/test_early_fetch.py

@@ -0,0 +1,124 @@
+"""
+Unit tests for GlobalField.fetch method in contentstack.globalfields
+"""
+
+import pytest
+from unittest.mock import MagicMock
+from contentstack.globalfields import GlobalField
+from urllib.parse import urlencode
+
+
+@pytest.fixture
+def mock_http_instance():
+    """
+    Fixture to provide a mock http_instance with required attributes.
+    """
+    mock = MagicMock()
+    mock.endpoint = "https://api.contentstack.io/v3"
+    mock.headers = {"environment": "test_env"}
+    mock.get = MagicMock(return_value={"global_field": "data"})
+    return mock
+
+
+@pytest.fixture
+def global_field_uid():
+    """
+    Fixture to provide a sample global_field_uid.
+    """
+    return "sample_uid"
+
+
+@pytest.fixture
+def global_field(mock_http_instance, global_field_uid):
+    """
+    Fixture to provide a GlobalField instance with a mock http_instance and uid.
+    """
+    return GlobalField(mock_http_instance, global_field_uid)
+
+
+class TestGlobalFieldFetch:
+    # ------------------- Happy Path Tests -------------------
+
+    def test_fetch_returns_expected_result(self, global_field):
+        """
+        Test that fetch returns the result from http_instance.get with correct URL and params.
+        """
+        result = global_field.fetch()
+        assert result == {"global_field": "data"}
+        assert global_field.local_param["environment"] == "test_env"
+        expected_params = urlencode({"environment": "test_env"})
+        expected_url = f"https://api.contentstack.io/v3/global_fields/sample_uid?{expected_params}"
+        global_field.http_instance.get.assert_called_once_with(expected_url)
+
+    def test_fetch_with_different_environment(self, mock_http_instance, global_field_uid):
+        """
+        Test fetch with a different environment value in headers.
+        """
+        mock_http_instance.headers["environment"] = "prod_env"
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        result = gf.fetch()
+        assert result == {"global_field": "data"}
+        expected_params = urlencode({"environment": "prod_env"})
+        expected_url = f"https://api.contentstack.io/v3/global_fields/sample_uid?{expected_params}"
+        mock_http_instance.get.assert_called_once_with(expected_url)
+
+    def test_fetch_preserves_existing_local_param(self, global_field):
+        """
+        Test that fetch overwrites only the 'environment' key in local_param, preserving others.
+        """
+        global_field.local_param = {"foo": "bar"}
+        result = global_field.fetch()
+        assert result == {"global_field": "data"}
+        assert global_field.local_param["foo"] == "bar"
+        assert global_field.local_param["environment"] == "test_env"
+        expected_params = urlencode({"foo": "bar", "environment": "test_env"})
+        expected_url = f"https://api.contentstack.io/v3/global_fields/sample_uid?{expected_params}"
+        global_field.http_instance.get.assert_called_once_with(expected_url)
+
+    # ------------------- Edge Case Tests -------------------
+
+    def test_fetch_raises_keyerror_when_uid_is_none(self, mock_http_instance):
+        """
+        Test that fetch raises KeyError if global_field_uid is None.
+        """
+        gf = GlobalField(mock_http_instance, None)
+        with pytest.raises(KeyError, match="global_field_uid can not be None"):
+            gf.fetch()
+
+    def test_fetch_raises_keyerror_when_uid_is_explicitly_set_to_none(self, mock_http_instance):
+        """
+        Test that fetch raises KeyError if global_field_uid is explicitly set to None after init.
+        """
+        gf = GlobalField(mock_http_instance, "not_none")
+        gf._GlobalField__global_field_uid = None  # forcibly set to None
+        with pytest.raises(KeyError, match="global_field_uid can not be None"):
+            gf.fetch()
+
+    def test_fetch_handles_special_characters_in_params(self, global_field):
+        """
+        Test that fetch correctly encodes special characters in local_param.
+        """
+        global_field.local_param = {"foo": "bar baz", "qux": "a&b"}
+        result = global_field.fetch()
+        assert result == {"global_field": "data"}
+        expected_params = urlencode({"foo": "bar baz", "qux": "a&b", "environment": "test_env"})
+        expected_url = f"https://api.contentstack.io/v3/global_fields/sample_uid?{expected_params}"
+        global_field.http_instance.get.assert_called_once_with(expected_url)
+
+    def test_fetch_raises_keyerror_if_environment_header_missing(self, mock_http_instance, global_field_uid):
+        """
+        Test that fetch raises KeyError if 'environment' is missing from http_instance.headers.
+        """
+        del mock_http_instance.headers["environment"]
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        with pytest.raises(KeyError):
+            gf.fetch()
+
+    def test_fetch_propagates_http_instance_get_exception(self, global_field):
+        """
+        Test that fetch propagates exceptions raised by http_instance.get.
+        """
+        global_field.http_instance.get.side_effect = RuntimeError("Network error")
+        with pytest.raises(RuntimeError, match="Network error"):
+            global_field.fetch()
+

contentstack-2.2.0/tests/test_early_find.py

@@ -0,0 +1,138 @@
+# test_globalfields_find.py
+
+import pytest
+from unittest.mock import MagicMock, patch
+from contentstack.globalfields import GlobalField
+
+@pytest.fixture
+def mock_http_instance():
+    """
+    Fixture to provide a mock http_instance with headers and endpoint.
+    """
+    mock = MagicMock()
+    mock.headers = {"environment": "test_env"}
+    mock.endpoint = "https://api.contentstack.io/v3"
+    mock.get = MagicMock(return_value={"global_fields": "data"})
+    return mock
+
+@pytest.fixture
+def global_field_uid():
+    """
+    Fixture to provide a sample global_field_uid.
+    """
+    return "sample_uid"
+
+class TestGlobalFieldFind:
+    """
+    Unit tests for GlobalField.find method, covering happy paths and edge cases.
+    """
+
+    # -------------------- Happy Path Tests --------------------
+
+    def test_find_with_no_params(self, mock_http_instance, global_field_uid):
+        """
+        Test that find() with no params returns expected result and constructs correct URL.
+        """
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        result = gf.find()
+        assert result == {"global_fields": "data"}
+        expected_url = (
+            "https://api.contentstack.io/v3/global_fields?environment=test_env"
+        )
+        mock_http_instance.get.assert_called_once_with(expected_url)
+
+    def test_find_with_params(self, mock_http_instance, global_field_uid):
+        """
+        Test that find() with additional params merges them and encodes URL correctly.
+        """
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        params = {"limit": 10, "skip": 5}
+        result = gf.find(params=params)
+        # The order of query params in the URL is not guaranteed, so check both possibilities
+        called_url = mock_http_instance.get.call_args[0][0]
+        assert result == {"global_fields": "data"}
+        assert called_url.startswith("https://api.contentstack.io/v3/global_fields?")
+        # All params must be present in the URL
+        for k, v in {"environment": "test_env", "limit": "10", "skip": "5"}.items():
+            assert f"{k}={v}" in called_url
+
+    def test_find_with_empty_params_dict(self, mock_http_instance, global_field_uid):
+        """
+        Test that find() with an empty params dict behaves like no params.
+        """
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        result = gf.find(params={})
+        assert result == {"global_fields": "data"}
+        expected_url = (
+            "https://api.contentstack.io/v3/global_fields?environment=test_env"
+        )
+        mock_http_instance.get.assert_called_once_with(expected_url)
+
+   
+
+    def test_find_with_special_characters_in_params(self, mock_http_instance, global_field_uid):
+        """
+        Test that find() correctly URL-encodes special characters in params.
+        """
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        params = {"q": "name:foo/bar&baz", "limit": 1}
+        result = gf.find(params=params)
+        called_url = mock_http_instance.get.call_args[0][0]
+        # Check that special characters are URL-encoded
+        assert "q=name%3Afoo%2Fbar%26baz" in called_url
+        assert "limit=1" in called_url
+        assert result == {"global_fields": "data"}
+
+    def test_find_with_none_environment_in_headers(self, mock_http_instance, global_field_uid):
+        """
+        Test that find() handles the case where 'environment' in headers is None.
+        """
+        mock_http_instance.headers["environment"] = None
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        result = gf.find()
+        called_url = mock_http_instance.get.call_args[0][0]
+        # Should include 'environment=None' in the query string
+        assert "environment=None" in called_url
+        assert result == {"global_fields": "data"}
+
+    def test_find_with_non_string_param_values(self, mock_http_instance, global_field_uid):
+        """
+        Test that find() handles non-string param values (e.g., int, bool, None).
+        """
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        params = {"int_val": 42, "bool_val": True, "none_val": None}
+        result = gf.find(params=params)
+        called_url = mock_http_instance.get.call_args[0][0]
+        # int and bool should be stringified, None should be 'None'
+        assert "int_val=42" in called_url
+        assert "bool_val=True" in called_url
+        assert "none_val=None" in called_url
+        assert result == {"global_fields": "data"}
+
+    def test_find_with_empty_headers(self, global_field_uid):
+        """
+        Test that find() raises KeyError if 'environment' is missing from headers.
+        """
+        mock_http_instance = MagicMock()
+        mock_http_instance.headers = {}
+        mock_http_instance.endpoint = "https://api.contentstack.io/v3"
+        mock_http_instance.get = MagicMock(return_value={"global_fields": "data"})
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        with pytest.raises(KeyError):
+            gf.find()
+
+
+    def test_find_with_mutable_local_param(self, mock_http_instance, global_field_uid):
+        """
+        Test that local_param is updated and persists between calls.
+        """
+        gf = GlobalField(mock_http_instance, global_field_uid)
+        # First call with a param
+        gf.find(params={"foo": "bar"})
+        # Second call with a different param
+        gf.find(params={"baz": "qux"})
+        # local_param should have been updated with the last call's params
+        assert gf.local_param["baz"] == "qux"
+        assert gf.local_param["environment"] == "test_env"
+        # The previous param 'foo' should still be present (since update is cumulative)
+        assert gf.local_param["foo"] == "bar"

{contentstack-2.0.1 → contentstack-2.2.0}/tests/test_entry.py

@@ -3,12 +3,12 @@ import unittest
 import config
 import contentstack
 
-_UID = 'blt53ca1231625bdde4'
 API_KEY = config.APIKEY
 DELIVERY_TOKEN = config.DELIVERYTOKEN
 ENVIRONMENT = config.ENVIRONMENT
 HOST = config.HOST
-
+FAQ_UID = config.FAQ_UID  # Add this in your config.py
+VARIANT_UID = config.VARIANT_UID
 
 class TestEntry(unittest.TestCase):
 
@@ -19,69 +19,54 @@ class TestEntry(unittest.TestCase):
         query = self.stack.content_type('faq').query()
         result = query.find()
         if result is not None:
-            self._UID = result['entries'][0]['uid']
-            print(f'the uid is: {_UID}')
+            self.faq_uid = result['entries'][0]['uid']
+            print(f'the uid is: {self.faq_uid}')
 
     def test_entry_by_UID(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID)
+        entry = self.stack.content_type('faq').entry(FAQ_UID)
         result = entry.fetch()
         if result is not None:
-            _UID = result['entry']['uid']
-            self.assertEqual(_UID, result['entry']['uid'])
+            self.assertEqual(FAQ_UID, result['entry']['uid'])
 
     def test_03_entry_environment(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).environment('test')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).environment('test')
         self.assertEqual("test", entry.http_instance.headers['environment'])
 
     def test_04_entry_locale(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID).locale('en-ei')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).locale('en-ei')
         entry.fetch()
         self.assertEqual('en-ei', entry.entry_param['locale'])
 
     def test_05_entry_version(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID).version(3)
+        entry = self.stack.content_type('faq').entry(FAQ_UID).version(3)
         entry.fetch()
         self.assertEqual(3, entry.entry_param['version'])
 
     def test_06_entry_params(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).param('param_key', 'param_value')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).param('param_key', 'param_value')
         entry.fetch()
         self.assertEqual('param_value', entry.entry_param['param_key'])
 
     def test_07_entry_base_only(self):
-        global _UID
-        entry = self.stack.content_type(
-            'faq').entry(_UID).only('field_UID')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).only('field_UID')
         entry.fetch()
         self.assertEqual({'environment': 'development',
                           'only[BASE][]': 'field_UID'}, entry.entry_param)
 
     def test_08_entry_base_excepts(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).excepts('field_UID')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).excepts('field_UID')
         entry.fetch()
         self.assertEqual({'environment': 'development',
                           'except[BASE][]': 'field_UID'}, entry.entry_param)
 
     def test_10_entry_base_include_reference_only(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(_UID).only('field1')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).only('field1')
         entry.fetch()
         self.assertEqual({'environment': 'development', 'only[BASE][]': 'field1'},
                          entry.entry_param)
 
     def test_11_entry_base_include_reference_excepts(self):
-        global _UID
-        entry = self.stack.content_type(
-            'faq').entry(_UID).excepts('field1')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).excepts('field1')
         entry.fetch()
         self.assertEqual({'environment': 'development', 'except[BASE][]': 'field1'},
                          entry.entry_param)
@@ -95,15 +80,13 @@ class TestEntry(unittest.TestCase):
         response = _entry.fetch()
 
     def test_13_entry_support_include_fallback_unit_test(self):
-        global _UID
-        entry = self.stack.content_type('faq').entry(
-            _UID).include_fallback()
+        entry = self.stack.content_type('faq').entry(FAQ_UID).include_fallback()
         self.assertEqual(
             True, entry.entry_param.__contains__('include_fallback'))
 
     def test_14_entry_queryable_only(self):
         try:
-            entry = self.stack.content_type('faq').entry(_UID).only(4)
+            entry = self.stack.content_type('faq').entry(FAQ_UID).only(4)
             result = entry.fetch()
             self.assertEqual(None, result['uid'])
         except KeyError as e:
@@ -112,7 +95,7 @@ class TestEntry(unittest.TestCase):
 
     def test_entry_queryable_excepts(self):
         try:
-            entry = self.stack.content_type('faq').entry(_UID).excepts(4)
+            entry = self.stack.content_type('faq').entry(FAQ_UID).excepts(4)
             result = entry.fetch()
             self.assertEqual(None, result['uid'])
         except KeyError as e:
@@ -120,20 +103,17 @@ class TestEntry(unittest.TestCase):
                 self.assertEqual("Invalid field_UID provided", e.args[0])
 
     def test_16_entry_queryable_include_content_type(self):
-        entry = self.stack.content_type('faq').entry(
-            _UID).include_content_type()
+        entry = self.stack.content_type('faq').entry(FAQ_UID).include_content_type()
         self.assertEqual({'include_content_type': 'true', 'include_global_field_schema': 'true'},
                          entry.entry_queryable_param)
 
     def test_reference_content_type_uid(self):
-        entry = self.stack.content_type('faq').entry(
-            _UID).include_reference_content_type_uid()
+        entry = self.stack.content_type('faq').entry(FAQ_UID).include_reference_content_type_uid()
         self.assertEqual({'include_reference_content_type_uid': 'true'},
                          entry.entry_queryable_param)
 
     def test_19_entry_queryable_add_param(self):
-        entry = self.stack.content_type('faq').entry(
-            _UID).add_param('cms', 'contentstack')
+        entry = self.stack.content_type('faq').entry(FAQ_UID).add_param('cms', 'contentstack')
         self.assertEqual({'cms': 'contentstack'}, entry.entry_queryable_param)
 
     def test_20_entry_include_fallback(self):
@@ -154,6 +134,28 @@ class TestEntry(unittest.TestCase):
         content_type = self.stack.content_type('faq')
         entry = content_type.entry("878783238783").include_metadata()
         self.assertEqual({'include_metadata': 'true'}, entry.entry_queryable_param)
+                
+    def test_23_content_type_variants(self):
+        content_type = self.stack.content_type('faq')
+        entry = content_type.variants(VARIANT_UID).find()
+        self.assertIn('variants', entry['entries'][0]['publish_details'])
+        
+    def test_24_entry_variants(self):
+        content_type = self.stack.content_type('faq')
+        entry = content_type.entry(FAQ_UID).variants(VARIANT_UID).fetch()
+        self.assertIn('variants', entry['entry']['publish_details'])
+        
+    def test_25_content_type_variants_with_has_hash_variant(self):
+        content_type = self.stack.content_type('faq')
+        entry = content_type.variants([VARIANT_UID]).find()
+        self.assertIn('variants', entry['entries'][0]['publish_details'])
+        
+    def test_25_content_type_entry_variants_with_has_hash_variant(self):
+        content_type = self.stack.content_type('faq').entry(FAQ_UID)
+        entry = content_type.variants([VARIANT_UID]).fetch()
+        self.assertIn('variants', entry['entry']['publish_details'])
+        
+        
 
 
 if __name__ == '__main__':

contentstack-2.2.0/tests/test_global_fields.py

@@ -0,0 +1,98 @@
+# test_globalfields_init.py
+
+import pytest
+import logging
+from contentstack.globalfields import GlobalField
+
+class DummyHttpInstance:
+    """A dummy HTTP instance for testing purposes."""
+    pass
+
+@pytest.fixture
+def dummy_http():
+    """Fixture to provide a dummy http_instance."""
+    return DummyHttpInstance()
+
+@pytest.fixture
+def dummy_logger():
+    """Fixture to provide a dummy logger."""
+    return logging.getLogger("dummy_logger")
+
+@pytest.mark.usefixtures("dummy_http")
+class TestGlobalFieldInit:
+    """
+    Unit tests for GlobalField.__init__ method.
+    """
+
+    # -------------------- Happy Path Tests --------------------
+
+    def test_init_with_all_arguments(self, dummy_http, dummy_logger):
+        """
+        Test that __init__ correctly assigns all arguments when all are provided.
+        """
+        uid = "global_field_123"
+        gf = GlobalField(dummy_http, uid, logger=dummy_logger)
+        assert gf.http_instance is dummy_http
+        # Accessing the private variable via name mangling
+        assert gf._GlobalField__global_field_uid == uid
+        assert gf.local_param == {}
+        assert gf.logger is dummy_logger
+
+    def test_init_without_logger_uses_default(self, dummy_http):
+        """
+        Test that __init__ assigns a default logger if none is provided.
+        """
+        uid = "gf_uid"
+        gf = GlobalField(dummy_http, uid)
+        assert gf.http_instance is dummy_http
+        assert gf._GlobalField__global_field_uid == uid
+        assert gf.local_param == {}
+        # Should be a logger instance, and not None
+        assert isinstance(gf.logger, logging.Logger)
+        # Should be the logger for the module
+        assert gf.logger.name == "contentstack.globalfields"
+
+    # -------------------- Edge Case Tests --------------------
+
+    def test_init_with_none_uid(self, dummy_http):
+        """
+        Test that __init__ accepts None as global_field_uid.
+        """
+        gf = GlobalField(dummy_http, None)
+        assert gf._GlobalField__global_field_uid is None
+
+    def test_init_with_empty_string_uid(self, dummy_http):
+        """
+        Test that __init__ accepts empty string as global_field_uid.
+        """
+        gf = GlobalField(dummy_http, "")
+        assert gf._GlobalField__global_field_uid == ""
+
+    def test_init_with_non_string_uid(self, dummy_http):
+        """
+        Test that __init__ accepts non-string types for global_field_uid.
+        """
+        for val in [123, 45.6, {"a": 1}, [1, 2, 3], (4, 5), True, object()]:
+            gf = GlobalField(dummy_http, val)
+            assert gf._GlobalField__global_field_uid == val
+
+    def test_init_with_none_http_instance(self):
+        """
+        Test that __init__ accepts None as http_instance.
+        """
+        uid = "gf_uid"
+        gf = GlobalField(None, uid)
+        assert gf.http_instance is None
+        assert gf._GlobalField__global_field_uid == uid
+
+    def test_init_with_custom_logger_object(self, dummy_http):
+        """
+        Test that __init__ accepts any object as logger.
+        """
+        class DummyLogger:
+            def info(self, msg): pass
+        dummy = DummyLogger()
+        gf = GlobalField(dummy_http, "uid", logger=dummy)
+        assert gf.logger is dummy
+
+    

{contentstack-2.0.1 → contentstack-2.2.0}/tests/test_live_preview.py

@@ -4,9 +4,9 @@ import config
 import contentstack
 from contentstack.deep_merge_lp import DeepMergeMixin
 
-management_token = 'cs8743874323343u9'
-entry_uid = 'blt8743874323343u9'
-preview_token = 'abcdefgh1234567890'
+management_token = config.MANAGEMENT_TOKEN
+entry_uid = config.LIVE_PREVIEW_ENTRY_UID
+preview_token = config.PREVIEW_TOKEN
 
 _lp_query = {
     'live_preview': '#0#0#0#0#0#0#0#0#0#',

{contentstack-2.0.1 → contentstack-2.2.0}/tests/test_stack.py

@@ -131,11 +131,14 @@ class TestStack(unittest.TestCase):
             self.assertEqual(
                 'is not valid.', result['errors']['pagination_token'][0])
 
-    @unittest.skip('Work in progress')
-    def test_16_initialise_sync(self):
-        result = self.stack.sync_init()
-        if result is not None:
-            self.assertEqual(16, result['total_count'])
+    # Deprecated: This test was skipped due to deprecation of the sync_init feature or its API. 
+    # If sync_init is permanently removed or unsupported, this test should remain commented or be deleted.
+    # If migration or replacement is planned, update this test accordingly.
+    # @unittest.skip('Work in progress')
+    # def test_16_initialise_sync(self):
+    #     result = self.stack.sync_init()
+    #     if result is not None:
+    #         self.assertEqual(16, result['total_count'])
 
     def test_17_entry_with_sync_token(self):
         result = self.stack.sync_token('sync_token')