contentstack-utils 1.1.0__tar.gz → 1.2.2__tar.gz

{contentstack_utils-1.1.0 → contentstack_utils-1.2.2}/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2021 Contentstack
+Copyright 2023 Contentstack
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

{contentstack_utils-1.1.0 → contentstack_utils-1.2.2}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.1
 Name: contentstack_utils
-Version: 1.1.0
+Version: 1.2.2
 Summary: contentstack_utils is a Utility package for Contentstack headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-utils-python
 Author: contentstack
 License: MIT
-Platform: UNKNOWN
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
@@ -51,7 +50,7 @@ If you are using Contentstack Python SDK in your project by running the followin
 ## For the specific version
 
 ```python
-   pip install Contentstack==1.4.0
+   pip install Contentstack==1.5.1
 ```
 
 ## Usage
@@ -66,11 +65,9 @@ To render embedded items on the front-end, use the renderContents function, and
     from contentstack_utils.utils import Utils
     from contentstack_utils.render.options import Options
     
-    json_array # should be type of dictionary or list
-    rte_content = "html_string"
-    
-    callback = Options()
-    response = Utils.render_content(rte_content, json_array, callback)
+    json_array = {} # should be type of dictionary or list
+    option = Options()
+    response = Utils.render_content('html_string', json_array, option)
     print(response)
     
 ```
@@ -126,9 +123,24 @@ query = stack.content_type("content_type_uid").query()
 result = query.find()
 if result is not None and 'entries' in result:
    entry = result['entries']
-   for item in range:
+   for item in entry:
        option = Option()
        Utils.json_to_html(item, ['paragraph_text'], option)
 ```
 
+## GraphQL SRTE
+
+To get supercharged items from multiple entries, you need to provide the stack API key, delivery token, environment name, and content type’s UID. 
+
+```python
+import contentstack
 
+stack = contentstack.Stack('api_key','delivery_token','environment')
+query = stack.content_type("content_type_uid").query()
+result = query.find()
+if result is not None and 'entries' in result:
+   entry = result['entries']
+   for item in entry:
+       option = Option()
+       GQL.json_to_html(item, ['paragraph_text'], option)
+```

{contentstack_utils-1.1.0 → contentstack_utils-1.2.2}/README.md

@@ -31,7 +31,7 @@ If you are using Contentstack Python SDK in your project by running the followin
 ## For the specific version
 
 ```python
-   pip install Contentstack==1.4.0
+   pip install Contentstack==1.5.1
 ```
 
 ## Usage
@@ -46,11 +46,9 @@ To render embedded items on the front-end, use the renderContents function, and
     from contentstack_utils.utils import Utils
     from contentstack_utils.render.options import Options
     
-    json_array # should be type of dictionary or list
-    rte_content = "html_string"
-    
-    callback = Options()
-    response = Utils.render_content(rte_content, json_array, callback)
+    json_array = {} # should be type of dictionary or list
+    option = Options()
+    response = Utils.render_content('html_string', json_array, option)
     print(response)
     
 ```
@@ -106,7 +104,24 @@ query = stack.content_type("content_type_uid").query()
 result = query.find()
 if result is not None and 'entries' in result:
    entry = result['entries']
-   for item in range:
+   for item in entry:
        option = Option()
        Utils.json_to_html(item, ['paragraph_text'], option)
 ```
+
+## GraphQL SRTE
+
+To get supercharged items from multiple entries, you need to provide the stack API key, delivery token, environment name, and content type’s UID. 
+
+```python
+import contentstack
+
+stack = contentstack.Stack('api_key','delivery_token','environment')
+query = stack.content_type("content_type_uid").query()
+result = query.find()
+if result is not None and 'entries' in result:
+   entry = result['entries']
+   for item in entry:
+       option = Option()
+       GQL.json_to_html(item, ['paragraph_text'], option)
+```

{contentstack_utils-1.1.0 → contentstack_utils-1.2.2}/contentstack_utils.egg-info/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.1
 Name: contentstack-utils
-Version: 1.1.0
+Version: 1.2.2
 Summary: contentstack_utils is a Utility package for Contentstack headless CMS with an API-first approach.
 Home-page: https://github.com/contentstack/contentstack-utils-python
 Author: contentstack
 License: MIT
-Platform: UNKNOWN
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Intended Audience :: Developers
@@ -51,7 +50,7 @@ If you are using Contentstack Python SDK in your project by running the followin
 ## For the specific version
 
 ```python
-   pip install Contentstack==1.4.0
+   pip install Contentstack==1.5.1
 ```
 
 ## Usage
@@ -66,11 +65,9 @@ To render embedded items on the front-end, use the renderContents function, and
     from contentstack_utils.utils import Utils
     from contentstack_utils.render.options import Options
     
-    json_array # should be type of dictionary or list
-    rte_content = "html_string"
-    
-    callback = Options()
-    response = Utils.render_content(rte_content, json_array, callback)
+    json_array = {} # should be type of dictionary or list
+    option = Options()
+    response = Utils.render_content('html_string', json_array, option)
     print(response)
     
 ```
@@ -126,9 +123,24 @@ query = stack.content_type("content_type_uid").query()
 result = query.find()
 if result is not None and 'entries' in result:
    entry = result['entries']
-   for item in range:
+   for item in entry:
        option = Option()
        Utils.json_to_html(item, ['paragraph_text'], option)
 ```
 
+## GraphQL SRTE
+
+To get supercharged items from multiple entries, you need to provide the stack API key, delivery token, environment name, and content type’s UID. 
+
+```python
+import contentstack
 
+stack = contentstack.Stack('api_key','delivery_token','environment')
+query = stack.content_type("content_type_uid").query()
+result = query.find()
+if result is not None and 'entries' in result:
+   entry = result['entries']
+   for item in entry:
+       option = Option()
+       GQL.json_to_html(item, ['paragraph_text'], option)
+```

contentstack_utils-1.2.2/contentstack_utils.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+setup.py
+contentstack_utils.egg-info/PKG-INFO
+contentstack_utils.egg-info/SOURCES.txt
+contentstack_utils.egg-info/dependency_links.txt
+contentstack_utils.egg-info/top_level.txt
+tests/test_default_opt_others.py
+tests/test_gql_to_html_func.py
+tests/test_helper_node_to_html.py
+tests/test_item_types.py
+tests/test_metadata.py
+tests/test_option_render_mark.py
+tests/test_render_default_options.py
+tests/test_render_options.py
+tests/test_style_type.py
+tests/test_util_srte.py
+tests/test_utils.py

{contentstack_utils-1.1.0 → contentstack_utils-1.2.2}/setup.py

@@ -15,7 +15,7 @@ setup(
     long_description_content_type="text/markdown",
     url="https://github.com/contentstack/contentstack-utils-python",
     license='MIT',
-    version='1.1.0',
+    version='1.2.2',
     install_requires=[
         
     ],
@@ -32,6 +32,5 @@ setup(
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
     ],
-
     python_requires='>=3.6',
 )

contentstack_utils-1.2.2/tests/test_default_opt_others.py

@@ -0,0 +1,44 @@
+import json
+import os
+import unittest
+
+from contentstack_utils.helper.metadata import Metadata, StyleType
+from contentstack_utils.render import options
+
+
+def read_mock_path():
+    to_json = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                           'mocks', 'embedded_items_without_title.json')
+    with open(to_json) as file:
+        to_json = json.load(file)
+    return to_json['entries'][0]['_embedded_items']['rich_text_editor']
+
+
+class TestDefaultOptOther(unittest.TestCase):
+
+    def test_get_default_options_render_option_block_without_title(self):
+        to_json = read_mock_path()
+        dictionary = to_json[0]
+        default_opt = options.Options()
+        metadata = Metadata("Hi sample entry for embedding", "entry", 'bltb5a04880fbb74f26', 'samplect',
+                            StyleType.BLOCK, "this is outer html", 'samplect attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<div><p>removed_for_security_reasons</p><div><p>Content type: <span>samplect</span></p></div>', result)
+
+    def test_get_render_option_asset_without_title_link(self):
+        to_json = read_mock_path()
+        dictionary = to_json[0]
+        default_opt = options.Options()
+        metadata = Metadata("Hi sample entry for embedding", "entry", 'bltb5a04880fbb74f26', 'samplect',
+                            StyleType.DISPLAY, "this is outer html", 'samplect attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<img src=/sample-entry-one alt=samplect_filename/>', result)
+
+    def test_get_render_option_asset_without_title_filename_link(self):
+        to_json = read_mock_path()
+        dictionary = to_json[1]
+        default_opt = options.Options()
+        metadata = Metadata("Hi sample entry for embedding", "entry", 'b5a04880fbb74f26', 'samplect',
+                            StyleType.DISPLAY, "this is outer html", 'samplect attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<img src=/sample-entry-one alt=removed_for_security_reasons/>', result)

contentstack_utils-1.2.2/tests/test_gql_to_html_func.py

@@ -0,0 +1,37 @@
+import json
+import os
+import unittest
+
+from contentstack_utils.gql import GQL
+from contentstack_utils.render.options import Options
+
+
+def mock_entry():
+    path_gql = 'mocks/graphqlmock'
+    file = os.path.dirname(os.path.abspath(__file__))
+    gql_entry = os.path.join(file, path_gql, 'content.json')
+    with open(gql_entry) as file:
+        return json.load(file)
+
+
+class TestGQLToHtml(unittest.TestCase):
+    srt_zero = '<p></p><div><p>Abcd Three</p><div><p>Content type: <span></span></p></div>'
+
+    def setUp(self):
+        print("logger for convert style")
+
+    def test_read_entry(self):
+        entry = mock_entry()
+        self.assertIsNotNone(entry)
+
+    def test_read_entry_uid(self):
+        entry = mock_entry()
+        self.assertEqual('sameple_uid', entry['srte']['json'][0]['uid'])
+
+    def test_gql_to_html(self):
+        entry = mock_entry()
+        option = Options()
+        path_keys = ['srte']
+        GQL.json_to_html(entry, path_keys, option)
+        self.assertEqual(entry['srte'][0],
+                         '<p></p><div><p>Abcd Three</p><div><p>Content type: <span></span></p></div>')

contentstack_utils-1.2.2/tests/test_helper_node_to_html.py

@@ -0,0 +1,61 @@
+import unittest
+
+from contentstack_utils.helper.node_to_html import NodeToHtml
+from contentstack_utils.render.options import Options
+
+
+class TestHelperNodeToHtml(unittest.TestCase):
+    node_dict = {
+        "text": "Lorem ipsum dolor sit amet"
+    }
+
+    def setUp(self):
+        print("Test Helper Class Node To Html")
+
+    def test_test_helper_node_superscript(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)
+
+    def test_test_helper_node_subscript(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)
+
+    def test_test_helper_node_inline_code(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)
+
+    def test_test_helper_node_strikethrough(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)
+
+    def test_test_helper_node_underline(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)
+
+    def test_test_helper_node_italic(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)
+
+    def test_test_helper_node_bold(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)
+
+    def test_test_helper_node_undefined(self):
+        option = Options()
+        what_does_it_returns = NodeToHtml.text_node_to_html(self.node_dict, option)
+        print(what_does_it_returns)
+        self.assertEqual("Lorem ipsum dolor sit amet", what_does_it_returns)

contentstack_utils-1.2.2/tests/test_item_types.py

@@ -0,0 +1,13 @@
+import unittest
+from contentstack_utils.embedded.item_type import ItemType
+
+
+class TestItemType(unittest.TestCase):
+
+    def test_item_type_entry(self):
+        typeof = ItemType.ENTRY
+        self.assertEqual('entry', typeof.value)
+
+    def test_item_type_asset(self):
+        typeof = ItemType.ASSET
+        self.assertEqual('asset', typeof.value)

contentstack_utils-1.2.2/tests/test_metadata.py

@@ -0,0 +1,53 @@
+import unittest
+from contentstack_utils.embedded.styletype import StyleType
+from contentstack_utils.helper.metadata import Metadata
+
+
+class TestMetadata(unittest.TestCase):
+
+    def setUp(self):
+        self.metadata = Metadata('product', 'entry', 'blt87483473746', 'products', 
+        StyleType.BLOCK, 'text_for_outer_html', 'attributes_is_string_for, now')
+
+    def test_metadata_mojo(self):
+        self.assertIsNotNone(self.metadata)
+
+    def test_metadata_object_text(self):
+        self.assertIsNotNone(self.metadata.get_text)
+
+    def test_metadata_object_attributes(self):
+        self.assertIsNotNone(self.metadata.get_attributes)
+
+    def test_metadata_object_outer_html(self):
+        self.assertIsNotNone(self.metadata.outer_html)
+
+    def test_metadata_item_type(self):
+        self.assertIsNotNone(self.metadata.get_item_type)
+
+    def test_metadata_item_uid(self):
+        self.assertIsNotNone(self.metadata.get_item_uid)
+
+    def test_metadata_content_type_uid(self):
+        self.assertIsNotNone(self.metadata.get_content_type_uid)
+
+    def test_metadata_style_type(self):
+        self.assertIsNotNone(self.metadata.get_style_type)
+
+    def test_metadata_object_text_value(self):
+        self.assertEqual('product', self.metadata.get_text)
+
+    def test_outer_html(self):
+        self.assertEqual('text_for_outer_html', self.metadata.get_outer_html)
+
+    def test_metadata_item_type_value(self):
+        self.assertEqual('entry', self.metadata.get_item_type)
+
+    def test_metadata_item_uid_value(self):
+        self.assertEqual('blt87483473746', self.metadata.get_item_uid)
+
+    def test_metadata_content_type_uid_value(self):
+        self.assertEqual('products', self.metadata.get_content_type_uid)
+
+    def test_metadata_style_type_value(self):
+        self.assertEqual('block', self.metadata.get_style_type.value)
+

contentstack_utils-1.2.2/tests/test_option_render_mark.py

@@ -0,0 +1,52 @@
+import json
+import os
+import unittest
+from contentstack_utils import Utils
+from contentstack_utils.render.options import Options
+from tests.mocks.supercharged.results import Results
+
+
+class TestOptionRenderMark(unittest.TestCase):
+
+    def setUp(self):
+        print("print for getting started option render mark")
+
+    def test_option_render_mark_superscript_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("superscript", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("<sup>some_string_for_example</sup>", what_does_it_returns)
+
+    def test_option_render_mark_subscript_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("subscript", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("<sub>some_string_for_example</sub>", what_does_it_returns)
+
+    def test_option_render_mark_inline_code_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("inlineCode", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("<span>some_string_for_example</span>", what_does_it_returns)
+
+    def test_option_render_mark_strikethrough_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("strikethrough", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("<strike>some_string_for_example</strike>", what_does_it_returns)
+
+    def test_option_render_mark_underline_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("underline", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("<u>some_string_for_example</u>", what_does_it_returns)
+
+    def test_option_render_mark_italic_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("italic", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("<em>some_string_for_example</em>", what_does_it_returns)
+
+    def test_option_render_mark_bold_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("bold", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("<strong>some_string_for_example</strong>", what_does_it_returns)
+
+    def test_option_render_mark_undefined_supercharged_stringify(self):
+        what_does_it_returns = Options.render_mark("", "some_string_for_example")
+        print(what_does_it_returns)
+        self.assertEqual("some_string_for_example", what_does_it_returns)

contentstack_utils-1.2.2/tests/test_render_default_options.py

@@ -0,0 +1,82 @@
+import json
+import os
+import unittest
+
+from contentstack_utils.helper.metadata import Metadata, StyleType
+from contentstack_utils.render import options
+
+
+def _is_json(file):
+    try:
+        json.dumps(file)
+        return True
+    except ValueError:
+        return False
+
+
+def read_mock_path():
+    to_json = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                           'mocks', 'embedded_items.json')
+    with open(to_json) as file:
+        to_json = json.load(file)
+    return to_json['entries'][0]
+
+
+class TestRenderDefaultOption(unittest.TestCase):
+
+    def test_read_json_file_by_absolute_path(self):
+        self.assertIsNotNone(read_mock_path())
+
+    def test_read_json_file_by_content_path(self):
+        result = _is_json("/tests/mocks/embedded_items.json")
+        instance = isinstance(result, bool)
+        self.assertTrue(instance, 'this is to check the bool value')
+
+    def test_get_title_or_uid(self):
+        should_return_title = options._title_or_uid(read_mock_path())
+        self.assertEqual("Entry one", should_return_title, "It should match dictionary title")
+
+    def test_get_asset_title_or_uid(self):
+        should_return_title = options._asset_title_or_uid(read_mock_path())
+        self.assertEqual("Entry one", should_return_title, "It should match dictionary title")
+
+    def test_get_default_options_render_option_block(self):
+        dictionary = read_mock_path()['_embedded_items']['rich_text_editor'][0]
+        default_opt = options.Options()
+        metadata = Metadata("Hi sample entry for embedding", "entry", 'bltb5a04880fbb74f26', 'samplect',
+                            StyleType.BLOCK, "this is outer html", 'samplect attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual("<div><p>Hi sample entry for embedding</p><div><p>Content type: "
+                         "<span>samplect</span></p></div>", result)
+
+    def test_get_default_options_render_option_inline(self):
+        dictionary = read_mock_path()['_embedded_items']['rich_text_editor'][0]
+        default_opt = options.Options()
+        metadata = Metadata("this is sample text", "entry", 'blt8928738723', 'products',
+                            StyleType.INLINE, "this is outer html", 'sample attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<span>Hi sample entry for embedding</span>', result)
+
+    def test_get_default_options_render_option_link(self):
+        dictionary = read_mock_path()['_embedded_items']['rich_text_editor'][0]
+        default_opt = options.Options()
+        metadata = Metadata("this is sample text", "entry", 'blt8928738723', 'products',
+                            StyleType.LINK, "this is outer html", 'sample attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<a href=/sample-entry-one>Hi sample entry for embedding</a>', result)
+
+    def test_get_default_options_render_asset_display(self):
+        dictionary = read_mock_path()['_embedded_items']['rich_text_editor'][0]
+        default_opt = options.Options()
+        metadata = Metadata("this is sample text", "asset", 'blt8928738723', 'products',
+                            StyleType.DISPLAY, "this is outer html", 'sample attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<img src=/sample-entry-one alt=Hi sample entry for embedding/>', result)
+
+    def test_get_default_options_render_asset_none(self):
+        dictionary = read_mock_path()['_embedded_items']['rich_text_editor'][0]
+        default_opt = options.Options()
+        metadata = Metadata("this is sample text", "asset", 'blt8928738723', 'products',
+                            StyleType.DOWNLOAD, "this is outer html", 'sample attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<a href=/sample-entry-one>Hi sample entry for embedding</a>', result)

contentstack_utils-1.2.2/tests/test_render_options.py

@@ -0,0 +1,36 @@
+import os
+import unittest
+import json
+from contentstack_utils.helper.metadata import Metadata, StyleType
+from contentstack_utils.render import options
+
+
+def read_mock_path(path):
+    path_to_json = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                'mocks', path)
+    return path_to_json
+
+
+class TestRenderOption(unittest.TestCase):
+
+    def test_get_default_options_render_asset_display(self):
+        json_array = None
+        path = read_mock_path('embedded_items.json')
+        with open(path) as file:
+            json_array = json.load(file)
+        dictionary = json_array['entries'][0]['_embedded_items']['rich_text_editor'][0]
+        default_opt = options.Options()
+        metadata = Metadata("this is sample text", "asset", 'blt8928738723', 'products',
+                            StyleType.DISPLAY, "this is outer html", 'sample attributes')
+        result = default_opt.render_options(dictionary, metadata)
+        self.assertEqual('<img src=/sample-entry-one alt=Hi sample entry for embedding/>', result)
+
+    def test_get_default_options_render_no_style(self):
+        with open('tests/mocks/embedded_items.json', 'r') as f:
+            array = json.load(f)
+            dictionary = array['entries'][0]['_embedded_items']['rich_text_editor'][0]
+            default_opt = options.Options()
+            metadata = Metadata("this is sample text", "asset", 'blt8928738723', 'products',
+                                StyleType.DOWNLOAD, "this is outer html", 'sample attributes')
+            result = default_opt.render_options(dictionary, metadata)
+            self.assertEqual('<a href=/sample-entry-one>Hi sample entry for embedding</a>', result)

contentstack_utils-1.2.2/tests/test_style_type.py

@@ -0,0 +1,26 @@
+import unittest
+
+from contentstack_utils.embedded.styletype import StyleType
+
+
+class TestStyleType(unittest.TestCase):
+
+    def test_style_type_block(self):
+        style = StyleType.BLOCK
+        self.assertEqual('block', style.value)
+
+    def test_style_type_inline(self):
+        style = StyleType.INLINE
+        self.assertEqual('inline', style.value)
+
+    def test_style_type_link(self):
+        style = StyleType.LINK
+        self.assertEqual('link', style.value)
+
+    def test_style_type_display(self):
+        style = StyleType.DISPLAY
+        self.assertEqual('display', style.value)
+
+    def test_style_type_downloadable(self):
+        style = StyleType.DOWNLOAD
+        self.assertEqual('download', style.value)

contentstack_utils-1.2.2/tests/test_util_srte.py

@@ -0,0 +1,114 @@
+import json
+import os
+import unittest
+from contentstack_utils import Utils
+from contentstack_utils.render.options import Options
+from tests.mocks.supercharged.results import Results
+
+
+def __is_json(file):
+    try:
+        json.dumps(file)
+        return True
+    except ValueError:
+        return False
+
+
+def load_mock():
+    path = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)),
+        'mocks/supercharged', 'supercharged.json')
+    with open(path) as file:
+        return json.load(file)
+
+
+class TestSuperchargedUtils(unittest.TestCase):
+    global _json_data  # Note that the PyCharm warnings are not actual python errors
+
+    def setUp(self):
+        self._json_data = load_mock()
+
+    def test_plaintext_in_supercharged_dict_to_html(self):
+        array_str = ['plaintext']
+        Utils.json_to_html(self._json_data, array_str, Options())
+        self.assertEqual(Results.plainTextHtml, self._json_data['plaintext'])
+
+    def test_plaintext_in_supercharged_list_to_html(self):
+        array_str = ['plaintext_array']
+        Utils.json_to_html(self._json_data, array_str, Options())
+        self.assertEqual(Results.plainTextHtml, self._json_data['plaintext_array'][0])
+
+    def test_paragraph_in_supercharged_dict_to_html(self):
+        array_str = ['paragraph']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.paragraphHtml, self._json_data['paragraph'])
+
+    def test_h1_in_supercharged_dict_to_html(self):
+        array_str = ['h_one']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h1Html, self._json_data['h_one'])
+
+    def test_h2_in_supercharged_dict_to_html(self):
+        array_str = ['h_two']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h2Html, self._json_data['h_two'])
+
+    def test_h3_in_supercharged_dict_to_html(self):
+        array_str = ['h_three']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h3Html, self._json_data['h_three'])
+
+    def test_h4_in_supercharged_dict_to_html(self):
+        array_str = ['h_four']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h4Html, self._json_data['h_four'])
+
+    def test_h5_in_supercharged_dict_to_html(self):
+        array_str = ['h_five']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h5Html, self._json_data['h_five'])
+
+    def test_h6_in_supercharged_dict_to_html(self):
+        array_str = ['h_six']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.h6Html, self._json_data['h_six'])
+
+    def test_order_list_in_supercharged_dict_to_html(self):
+        array_str = ['order_list']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.orderListHtml, self._json_data['order_list'])
+
+    def test_un_order_list_in_supercharged_dict_to_html(self):
+        array_str = ['un_order_list']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.unorderListHtml, self._json_data['un_order_list'])
+
+    def test_image_list_in_supercharged_dict_to_html(self):
+        array_str = ['img']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.imgHtml, self._json_data['img'])
+
+    def test_table_list_in_supercharged_dict_to_html(self):
+        array_str = ['table']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.tableHtml, self._json_data['table'])
+
+    def test_blockquote_list_in_supercharged_dict_to_html(self):
+        array_str = ['blockquote']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.blockquoteHtml, self._json_data['blockquote'])
+
+    def test_code_list_in_supercharged_dict_to_html(self):
+        array_str = ['code']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.codeHtml, self._json_data['code'])
+
+    def test_linkin_list_in_supercharged_dict_to_html(self):
+        array_str = ['link']
+        Utils.json_to_html([self._json_data], array_str, Options())
+        self.assertEqual(Results.linkInPHtml, self._json_data['link'])
+
+    # def test_reference_list_in_supercharged_dict_to_html(self):
+    #     array_str = ['reference']
+    #     Utils.json_to_html([self._json_data], array_str, Options())
+    #     self.assertEqual(Results.linkInPHtml, self._json_data['reference'])

contentstack_utils-1.2.2/tests/test_utils.py

@@ -0,0 +1,80 @@
+import json
+import os
+import unittest
+
+from contentstack_utils.render.options import Options
+from contentstack_utils.utils import Utils
+
+
+def _is_json(file):
+    try:
+        json.dumps(file)
+        return True
+    except ValueError:
+        return False
+
+
+def read_mock_path(path):
+    path_to_json = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                                'mocks', path)
+    return path_to_json
+
+
+class TestUtility(unittest.TestCase):
+
+    def test_cover_valid_json(self):
+        valid = _is_json(_is_json("outfile"))
+        self.assertTrue(valid)
+
+    def test_cover_render_fn_if_entry_obj_is_dict(self):
+        key_path = ['global_rich_multiple.group.rich_text_editor',
+                    'global_rich_multiple.group'
+                    '.rich_text_editor_multiple']
+        path = read_mock_path('multiple_rich_text_content.json')
+        with open(path) as file:
+            entry_list = json.load(file)['entries'][0]
+            option = Options()
+            return_value = Utils.render(entry_list, key_path, option)
+            self.assertIsNone(return_value)
+
+    def test_cover_render_fn_if_entry_obj_is_list(self):
+        key_path = ['global_rich_multiple.group.rich_text_editor',
+                    'global_rich_multiple.group'
+                    '.rich_text_editor_multiple']
+        path = read_mock_path('multiple_rich_text_content.json')
+        with open(path) as file:
+            entry_list = json.load(file)['entries']
+            option = Options()
+            return_value = Utils.render(entry_list, key_path, option)
+            self.assertIsNone(return_value)
+
+    def test_if_entry_object_render_content_asset(self):
+        path = read_mock_path('multiple_rich_text_content.json')
+        with open(path) as file:
+            json_array = json.load(file)
+            entry_list = json_array['entries'][0]
+            callback = Options()
+            rte_content = "<p>Global multiple group 1</p><figure class=\"embedded-asset\" " \
+                          "data-redactor-type=\"embed\" data-widget-code=\"\" " \
+                          "data-sys-asset-filelink=\"https://dev16-images.contentstack.com/v3/assets" \
+                          "/11.jpg\" " \
+                          "data-sys-asset-uid=\"7324a68403ee7281\" data-sys-asset-filename=\"11.jpg\" " \
+                          "data-sys-asset-contenttype=\"image/jpeg\" type=\"asset\" " \
+                          "sys-style-type=\"display\"></figure>"
+            response = Utils.render_content(rte_content, entry_list, callback, )
+            # self.assertEqual('<p>Global multiple group 1</p><img '
+            #                  'src=https://dev16-images.contentstack.com/v3/assets/'
+            #                  '11.jpg alt=11.jpg/>', response)
+
+    def test_if_entry_object_render_content_entry(self):
+        path = read_mock_path('multiple_rich_text_content.json')
+        with open(path) as file:
+            json_array = json.load(file)
+            entry_list = json_array['entries'][0]
+            option = Options()
+            rte_content = "<p><a data-sys-entry-uid=\"1c9e75e3608f8c6b\" data-sys-entry-locale=\"en-us\" " \
+                          "data-sys-content-type-uid=\"0_solve\" sys-style-type=\"link\" data-sys-can-edit=\"true\" " \
+                          "class=\"embedded-entry\" type=\"entry\" href=\"/untitled\" title=\"Entry 001 123\">Global " \
+                          "multiple modular 1</a></p>"
+            response = Utils.render_content(rte_content, entry_list, option)
+            self.assertEqual('<p><a href=/untitled>Entry 001 123</a></p>', response)

contentstack_utils-1.1.0/contentstack_utils.egg-info/SOURCES.txt

@@ -1,7 +0,0 @@
-LICENSE
-README.md
-setup.py
-contentstack_utils.egg-info/PKG-INFO
-contentstack_utils.egg-info/SOURCES.txt
-contentstack_utils.egg-info/dependency_links.txt
-contentstack_utils.egg-info/top_level.txt