everysk-lib 1.10.2__cp312-cp312-win_amd64.whl

everysk/core/_tests/serialize/test_json.py

@@ -0,0 +1,336 @@
+###############################################################################
+#
+# (C) Copyright 2025 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+from everysk.config import settings
+from everysk.core.datetime import Date, DateTime
+from everysk.core.object import BaseDict, BaseObject
+from everysk.core.serialize import CLASS_KEY, dumps, loads
+from everysk.core.unittests import TestCase
+from everysk.sdk.entities.datastore.base import Datastore
+
+
+###############################################################################
+#   Serialize Dumps Test Case Implementation
+###############################################################################
+class SerializeJsonDumpsTestCase(TestCase):
+    def test_int(self):
+        self.assertEqual(dumps(1), '1')
+
+    def test_float(self):
+        self.assertEqual(dumps(1.1), '1.1')
+
+    def test_bytes(self):
+        self.assertEqual(dumps(b'bytes'), '{"__bytes__": {"encoding": "utf-8", "value": "bytes"}}')
+
+    def test_bytes_decode_bytes_true(self):
+        self.assertEqual(dumps(b'bytes', decode_bytes=True), '"bytes"')
+
+    def test_bytes_inside(self):
+        self.assertEqual(dumps({'key': b'bytes'}), '{"key": {"__bytes__": {"encoding": "utf-8", "value": "bytes"}}}')
+
+    def test_bytes_inside_decode_bytes_true(self):
+        self.assertEqual(dumps({'key': b'bytes'}, decode_bytes=True), '{"key": "bytes"}')
+
+    def test_bytes_decode_error(self):
+        self.assertEqual(
+            dumps({'key': b'Introdu\xe7\xe3o'}),
+            '{"key": {"__bytes__": {"encoding": "base64", "value": "SW50cm9kdefjbw=="}}}',
+        )
+
+    def test_str(self):
+        self.assertEqual(dumps('string'), '"string"')
+
+    def test_list(self):
+        self.assertEqual(dumps([1, 'string']), '[1, "string"]')
+
+    def test_tuple(self):
+        self.assertEqual(dumps((1, 'string')), '[1, "string"]')
+
+    def test_set(self):
+        # We need to use only one item because set changes the order randomly
+        self.assertEqual(dumps({1}), '[1]')
+
+    def test_frozenset(self):
+        # We need to use only one item because frozenset changes the order randomly
+        self.assertEqual(dumps(frozenset({1})), '[1]')
+
+    def test_dict(self):
+        self.assertEqual(dumps({'int': 1, 'str': 'string'}), '{"int": 1, "str": "string"}')
+
+    def test_bool(self):
+        self.assertEqual(dumps(True), 'true')
+
+    def test_none(self):
+        self.assertEqual(dumps(None), 'null')
+
+    def test_date(self):
+        self.assertEqual(dumps(Date(2023, 1, 1)), '{"__date__": "2023-01-01"}')
+
+    def test_datetime(self):
+        self.assertEqual(dumps(DateTime(2023, 1, 1, 12, 0, 0)), '{"__datetime__": "2023-01-01T12:00:00+00:00"}')
+
+    def test_undefined(self):
+        self.assertEqual(dumps(Undefined), 'null')
+
+    def test_undefined_true(self):
+        self.assertEqual(dumps(Undefined, use_undefined=True), '{"__undefined__": null}')
+
+    def test_date_format(self):
+        self.assertEqual(dumps(Date(2023, 1, 1), date_format='%Y%m%d'), '"20230101"')
+
+    def test_datetime_format(self):
+        self.assertEqual(dumps(DateTime(2023, 1, 1, 12, 0, 0), datetime_format='%Y%m%dT%H%M%S'), '"20230101T120000"')
+
+    def test_list_values(self):
+        values = [1, 'string', Date(2023, 1, 1), DateTime(2023, 1, 1, 12, 0, 0), Undefined, None]
+        self.assertEqual(
+            dumps(values, use_undefined=True),
+            '[1, "string", {"__date__": "2023-01-01"}, {"__datetime__": "2023-01-01T12:00:00+00:00"}, {"__undefined__": null}, null]',
+        )
+
+    def test_dict_values(self):
+        values = {
+            'int': 1,
+            'str': 'string',
+            'date': Date(2023, 1, 1),
+            'datetime': DateTime(2023, 1, 1, 12, 0, 0),
+            'undefined': Undefined,
+            'none': None,
+        }
+        self.assertEqual(
+            dumps(values, use_undefined=True),
+            '{"int": 1, "str": "string", "date": {"__date__": "2023-01-01"}, "datetime": {"__datetime__": "2023-01-01T12:00:00+00:00"}, "undefined": {"__undefined__": null}, "none": null}',
+        )
+
+    def test_protocol_json(self):
+        self.assertEqual(dumps(1, protocol='json'), '1')
+
+    def test_protocol_invalid(self):
+        with self.assertRaisesRegex(
+            ValueError, "Unsupported serialize protocol 'invalid'. Use 'json', 'orjson' or 'pickle'."
+        ):
+            dumps(1, protocol='invalid')
+
+    def test_allow_nan_true(self):
+        self.assertEqual(dumps(float('nan'), allow_nan=True), 'NaN')
+        self.assertEqual(dumps(float('inf'), allow_nan=True), 'Infinity')
+        self.assertEqual(dumps(float('-inf'), allow_nan=True), '-Infinity')
+
+    def test_allow_nan_false(self):
+        with self.assertRaisesRegex(ValueError, 'Out of range float values are not JSON compliant'):
+            dumps(float('nan'), allow_nan=False)
+        with self.assertRaisesRegex(ValueError, 'Out of range float values are not JSON compliant'):
+            dumps(float('inf'), allow_nan=False)
+        with self.assertRaisesRegex(ValueError, 'Out of range float values are not JSON compliant'):
+            dumps(float('-inf'), allow_nan=False)
+
+    def test_object(self):
+        class Test:
+            def __init__(self, value):
+                self.value = value
+
+        with self.assertRaisesRegex(TypeError, 'Object of type Test is not JSON serializable'):
+            dumps(Test(1))
+
+    def test_complex_object(self):
+        class BaseDictTest(BaseDict):
+            var1: BaseDict | None = None
+
+        self.assertEqual(
+            dumps(BaseDictTest(var1=BaseDict(a='foo', b='boo')), sort_keys=True),
+            '{"%s": "everysk.core._tests.serialize.test_json.BaseDictTest", "_errors": null, "_is_frozen": false, "_silent": false, "var1": {"%s": "everysk.core.object.BaseDict", "_errors": null, "_is_frozen": false, "_silent": false, "a": "foo", "b": "boo"}}'
+            % (CLASS_KEY, CLASS_KEY),
+        )
+
+    def test_complex_object_with_key_function(self):
+        class BaseDictTest2(BaseDict):
+            var1: BaseDict | None = None
+
+            def _process_var1(self, value):  # pylint: disable=unused-argument
+                return 'new_value'
+
+        self.assertEqual(
+            dumps(BaseDictTest2(var1=BaseDict(a='foo', b='boo')), sort_keys=True),
+            '{"%s": "everysk.core._tests.serialize.test_json.BaseDictTest2", "_errors": null, "_is_frozen": false, "_silent": false, "var1": "new_value"}'
+            % CLASS_KEY,
+        )
+
+    def test_base_object(self):
+        self.assertEqual(
+            dumps(BaseObject(a=1, b={}, c=[3]), sort_keys=True),
+            '{"%s": "everysk.core.object.BaseObject", "_errors": null, "_is_frozen": false, "_silent": false, "a": 1, "b": {}, "c": [3]}'
+            % CLASS_KEY,
+        )
+
+    def test_base_dict(self):
+        self.assertEqual(
+            dumps(BaseDict(a=1, b={}, c=[3]), sort_keys=True),
+            '{"%s": "everysk.core.object.BaseDict", "_errors": null, "_is_frozen": false, "_silent": false, "a": 1, "b": {}, "c": [3]}'
+            % CLASS_KEY,
+        )
+
+    def test_object_with_other_method(self):
+        class TestObject:
+            # pylint: disable=unused-argument
+            def to_my_name(self, *args, **kwargs):
+                return 'hi'
+
+            def to_native(self, *args, **kwargs):
+                return 'bye'
+
+        old = settings.SERIALIZE_CONVERT_METHOD_NAME
+        self.assertEqual(settings.SERIALIZE_CONVERT_METHOD_NAME, 'to_native')
+        self.assertEqual(dumps(TestObject()), '"bye"')
+
+        settings.SERIALIZE_CONVERT_METHOD_NAME = 'to_my_name'
+        self.assertEqual(settings.SERIALIZE_CONVERT_METHOD_NAME, 'to_my_name')
+        self.assertEqual(dumps(TestObject()), '"hi"')
+
+        settings.SERIALIZE_CONVERT_METHOD_NAME = old
+        self.assertEqual(settings.SERIALIZE_CONVERT_METHOD_NAME, 'to_native')
+
+    def test_return_str(self):
+        self.assertEqual(dumps('string', protocol='json', return_type='str'), '"string"')
+
+    def test_return_bytes(self):
+        self.assertEqual(dumps('string', protocol='json', return_type='bytes'), b'"string"')
+
+
+###############################################################################
+#   Serialize Loads Test Case Implementation
+###############################################################################
+class SerializeJsonLoadsTestCase(TestCase):
+    def test_int(self):
+        self.assertEqual(loads('1'), 1)
+
+    def test_float(self):
+        self.assertEqual(loads('1.1'), 1.1)
+
+    def test_str(self):
+        self.assertEqual(loads('"string"'), 'string')
+
+    def test_list(self):
+        self.assertEqual(loads('[1, "string"]'), [1, 'string'])
+
+    def test_dict(self):
+        self.assertEqual(loads('{"int": 1, "str": "string"}'), {'int': 1, 'str': 'string'})
+
+    def test_bool(self):
+        self.assertEqual(loads('true'), True)
+
+    def test_none(self):
+        self.assertIsNone(loads('null'))
+
+    def test_date(self):
+        self.assertEqual(loads('{"__date__": "2023-01-01"}'), Date(2023, 1, 1))
+
+    def test_datetime(self):
+        self.assertEqual(loads('{"__datetime__": "2023-01-01T12:00:00+00:00"}'), DateTime(2023, 1, 1, 12, 0, 0))
+
+    def test_undefined_true(self):
+        self.assertEqual(loads('{"__undefined__": null}', use_undefined=True), Undefined)
+
+    def test_undefined_false(self):
+        self.assertIsNone(loads('{"__undefined__": null}', use_undefined=False))
+
+    def test_null(self):
+        self.assertIsNone(loads('null'))
+
+    def test_date_format(self):
+        self.assertEqual(loads('{"__date__": "20230101"}', date_format='%Y%m%d'), Date(2023, 1, 1))
+
+    def test_datetime_format(self):
+        self.assertEqual(
+            loads('{"__datetime__": "20230101T120000"}', datetime_format='%Y%m%dT%H%M%S'),
+            DateTime(2023, 1, 1, 12, 0, 0),
+        )
+
+    def test_list_values(self):
+        values = [1, 'string', Date(2023, 1, 1), DateTime(2023, 1, 1, 12, 0, 0), Undefined, None]
+        self.assertEqual(
+            loads(
+                '[1, "string", {"__date__": "2023-01-01"}, {"__datetime__": "2023-01-01T12:00:00+00:00"}, {"__undefined__": null}, null]',
+                use_undefined=True,
+            ),
+            values,
+        )
+
+    def test_dict_values(self):
+        values = {
+            'int': 1,
+            'str': 'string',
+            'date': Date(2023, 1, 1),
+            'datetime': DateTime(2023, 1, 1, 12, 0, 0),
+            'undefined': Undefined,
+            'none': None,
+        }
+        self.assertEqual(
+            loads(
+                '{"int": 1, "str": "string", "date": {"__date__": "2023-01-01"}, "datetime": {"__datetime__": "2023-01-01T12:00:00+00:00"}, "undefined": {"__undefined__": null}, "none": null}',
+                use_undefined=True,
+            ),
+            values,
+        )
+
+    def test_protocol_json(self):
+        self.assertEqual(loads('1', protocol='json'), 1)
+
+    def test_protocol_invalid(self):
+        with self.assertRaisesRegex(
+            ValueError, "Unsupported serialize protocol 'invalid'. Use 'json', 'orjson' or 'pickle'."
+        ):
+            loads('1', protocol='invalid')
+
+    def test_nan(self):
+        nan = loads('NaN')
+        self.assertNotEqual(nan, nan)
+
+    def test_inf(self):
+        self.assertEqual(loads('Infinity'), float('inf'))
+        self.assertEqual(loads('-Infinity'), float('-inf'))
+
+    def test_bytes(self):
+        self.assertEqual(loads(b'1'), 1)
+
+    def test_bytes_inside(self):
+        self.assertEqual(loads('{"key": {"__bytes__": {"encoding": "utf-8", "value": "bytes"}}}'), {'key': b'bytes'})
+
+    def test_bytes_decode_error(self):
+        self.assertEqual(
+            loads('{"key": {"__bytes__": {"encoding": "base64", "value": "SW50cm9kdefjbw=="}}}'),
+            {'key': b'Introdu\xe7\xe3o'},
+        )
+
+    def test_base_object(self):
+        ret = loads('{"%s": "everysk.core.object.BaseObject", "a": 1, "b": {}, "c": [3]}' % CLASS_KEY)
+        self.assertIsInstance(ret, BaseObject)
+        self.assertEqual(ret.a, 1)
+        self.assertEqual(ret.b, {})
+        self.assertEqual(ret.c, [3])
+
+        ret = loads('{"%s": "app.var.test.Foo", "a": 1, "b": {}, "c": [3]}' % CLASS_KEY)
+        self.assertIsInstance(ret, BaseObject)
+        self.assertEqual(ret.a, 1)
+        self.assertEqual(ret.b, {})
+        self.assertEqual(ret.c, [3])
+
+    def test_base_dict(self):
+        self.assertDictEqual(
+            loads('{"%s": "everysk.core.object.BaseDict", "a": 1, "b": {}, "c": [3]}' % CLASS_KEY),
+            BaseDict(a=1, b={}, c=[3]),
+        )
+
+    def test_internal_entity(self):
+        self.assertIsInstance(
+            loads(
+                '{"%s": "engines.sample.Datastore", "workspace": null, "tags": [], "data": null, "id": null, "description": null, "updated_on": {"__datetime__": "2024-08-28T15:18:44.386204+00:00"}, "link_uid": null, "created_on": {"__datetime__": "2024-08-28T15:18:44.386204+00:00"}, "name": null, "level": null, "date": null, "version": "v1"}'
+                % CLASS_KEY
+            ),
+            Datastore,
+        )

everysk/core/_tests/serialize/test_orjson.py

@@ -0,0 +1,295 @@
+###############################################################################
+#
+# (C) Copyright 2025 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+import os
+from json import JSONDecodeError
+
+from everysk.core.datetime import Date, DateTime
+from everysk.core.object import BaseDict, BaseObject
+from everysk.core.serialize import dumps, loads
+from everysk.core.unittests import TestCase
+
+PDF = (
+    'JVBERi0xLjcKJcOkw7zDtsOfCjIgMCBvYmoKPDwvTGVuZ3RoIDMgMCBSL0ZpbHRlci9GbGF0ZURlY29kZT4+CnN0cmVhbQp4nDPQM1Qo59J3LCrJTEtMLlFw8nXmKlQ'
+    'wUDDQMzCyUDC1NNUzMjdVsDAx1LMwM1QoSuUK11LI43IFqgpUAAC+aw3mCmVuZHN0cmVhbQplbmRvYmoKCjMgMCBvYmoKNjcKZW5kb2JqCgo2IDAgb2JqCjw8Cj4+Cm'
+    'VuZG9iagoKNyAwIG9iago8PAovRm9udCA2IDAgUgovUHJvY1NldFsvUERGL1RleHRdCj4+CmVuZG9iagoKMSAwIG9iago8PC9UeXBlL1BhZ2UvUGFyZW50IDUgMCBSL'
+    '1Jlc291cmNlcyA3IDAgUi9NZWRpYUJveFswIDAgNTk1LjMwMzkzNzAwNzg3NCA4NDEuODg5NzYzNzc5NTI4XS9UYWJzL1MKL0NvbnRlbnRzIDIgMCBSPj4KZW5kb2Jq'
+    'Cgo0IDAgb2JqCjw8L1R5cGUvU3RydWN0RWxlbQovUy9Eb2N1bWVudAovUCA4IDAgUgovUGcgMSAwIFIKPj4KZW5kb2JqCgo4IDAgb2JqCjw8L1R5cGUvU3RydWN0VHJ'
+    'lZVJvb3QKL1BhcmVudFRyZWUgOSAwIFIKL0tbNCAwIFIgIF0KPj4KZW5kb2JqCgo5IDAgb2JqCjw8L051bXNbCl0+PgplbmRvYmoKCjUgMCBvYmoKPDwvVHlwZS9QYW'
+    'dlcwovUmVzb3VyY2VzIDcgMCBSCi9LaWRzWyAxIDAgUiBdCi9Db3VudCAxPj4KZW5kb2JqCgoxMCAwIG9iago8PC9UeXBlL0NhdGFsb2cvUGFnZXMgNSAwIFIKL1BhZ'
+    '2VNb2RlL1VzZU91dGxpbmVzCi9PcGVuQWN0aW9uWzEgMCBSIC9YWVogbnVsbCBudWxsIDBdCi9TdHJ1Y3RUcmVlUm9vdCA4IDAgUgovTGFuZyhwdC1CUikKL01hcmtJ'
+    'bmZvPDwvTWFya2VkIHRydWU+Pgo+PgplbmRvYmoKCjExIDAgb2JqCjw8L0NyZWF0b3I8RkVGRjAwNTcwMDcyMDA2OTAwNzQwMDY1MDA3Mj4KL1Byb2R1Y2VyPEZFRkY'
+    'wMDRDMDA2OTAwNjIwMDcyMDA2NTAwNEYwMDY2MDA2NjAwNjkwMDYzMDA2NTAwMjAwMDMyMDAzNDAwMkUwMDMyPgovQ3JlYXRpb25EYXRlKEQ6MjAyNTA1MjAxNjEzND'
+    'MtMDMnMDAnKT4+CmVuZG9iagoKeHJlZgowIDEyCjAwMDAwMDAwMDAgNjU1MzUgZiAKMDAwMDAwMDI1MiAwMDAwMCBuIAowMDAwMDAwMDE5IDAwMDAwIG4gCjAwMDAwM'
+    'DAxNTcgMDAwMDAgbiAKMDAwMDAwMDM4MyAwMDAwMCBuIAowMDAwMDAwNTUzIDAwMDAwIG4gCjAwMDAwMDAxNzYgMDAwMDAgbiAKMDAwMDAwMDE5OCAwMDAwMCBuIAow'
+    'MDAwMDAwNDUyIDAwMDAwIG4gCjAwMDAwMDA1MjQgMDAwMDAgbiAKMDAwMDAwMDYyNiAwMDAwMCBuIAowMDAwMDAwNzkzIDAwMDAwIG4gCnRyYWlsZXIKPDwvU2l6ZSA'
+    'xMi9Sb290IDEwIDAgUgovSW5mbyAxMSAwIFIKL0lEIFsgPDQzMTkzRDFENDQ4NDI4MUFCQ0ZCMzYzMEU0RkMzNDY3Pgo8NDMxOTNEMUQ0NDg0MjgxQUJDRkIzNjMwRT'
+    'RGQzM0Njc+IF0KL0RvY0NoZWNrc3VtIC8yMEIxOTM4NTMzNTVGQUQwMjFBRUU5MEU2ODFGMDk2QQo+PgpzdGFydHhyZWYKOTcyCiUlRU9GCg=='
+)
+
+PDF_PATH = os.path.join(os.path.dirname(__file__), 'example.pdf')
+
+
+class MyDict(dict):
+    pass
+
+
+class SerializeOrjsonDumpsTestCase(TestCase):
+    def setUp(self):
+        self.params: dict = {'protocol': 'orjson', 'sort_keys': True}
+
+    ## Constants
+    def test_none(self):
+        self.assertEqual(dumps(None, **self.params), 'null')
+
+    def test_bytes(self):
+        self.assertEqual(dumps(b'bytes', **self.params), '{"__bytes__": {"encoding": "utf-8", "value": "bytes"}}')
+
+    def test_bytes_decode_bytes_true(self):
+        self.assertEqual(dumps(b'bytes', decode_bytes=True, **self.params), '"bytes"')
+
+    def test_undefined_true(self):
+        self.assertEqual(dumps(Undefined, use_undefined=True, **self.params), '{"__undefined__":null}')
+
+    def test_undefined_false(self):
+        self.assertEqual(dumps(Undefined, use_undefined=False, **self.params), 'null')
+
+    def test_nan(self):
+        self.assertEqual(dumps(float('NaN'), use_undefined=False, **self.params), 'null')
+
+    def test_infinity(self):
+        self.assertEqual(dumps(float('Infinity'), use_undefined=False, **self.params), 'null')
+
+    def test_minus_infinity(self):
+        self.assertEqual(dumps(float('-Infinity'), use_undefined=False, **self.params), 'null')
+
+    def test_big_int(self):
+        self.assertEqual(dumps(123456789012345678901234567890, **self.params), '123456789012345678901234567890')
+
+    ## Basic types
+    def test_str(self):
+        self.assertEqual(dumps('teste', **self.params), '"teste"')
+
+    def test_bytes(self):
+        self.assertEqual(
+            dumps({'key': b'teste'}, **self.params), '{"key":{"__bytes__":{"encoding":"utf-8","value":"teste"}}}'
+        )
+
+    def test_bytes_decode_bytes_true(self):
+        self.assertEqual(dumps({'key': b'teste'}, decode_bytes=True, **self.params), '{"key":"teste"}')
+
+    def test_bytes_base64(self):
+        with open(PDF_PATH, 'rb') as fd:
+            data = fd.read()
+
+        self.assertEqual(
+            dumps({'key': data}, **self.params), (f'{{"key":{{"__bytes__":{{"encoding":"base64","value":"{PDF}"}}}}}}')
+        )
+
+    def test_int(self):
+        self.assertEqual(dumps(1, **self.params), '1')
+
+    def test_float(self):
+        self.assertEqual(dumps(1.0, **self.params), '1.0')
+
+    def test_true(self):
+        self.assertEqual(dumps(True, **self.params), 'true')
+
+    def test_false(self):
+        self.assertEqual(dumps(False, **self.params), 'false')
+
+    def test_tuple(self):
+        self.assertEqual(dumps((2, 'a', True), **self.params), '[2,"a",true]')
+
+    def test_list(self):
+        self.assertEqual(dumps([2, 'a', True], **self.params), '[2,"a",true]')
+
+    def test_set(self):
+        # set have random order so we use only one element
+        self.assertEqual(dumps({2}, **self.params), '[2]')
+
+    def test_dict(self):
+        self.assertEqual(dumps({'a': 1, '2': 'b'}, **self.params), '{"2":"b","a":1}')
+
+    def test_date(self):
+        self.assertEqual(dumps(Date(2025, 1, 1), **self.params), '{"__date__":"2025-01-01"}')
+
+    def test_date_with_format(self):
+        self.assertEqual(dumps(Date(2025, 1, 1), date_format='%Y-%m-%d', **self.params), '"2025-01-01"')
+
+    def test_datetime_big_int_nan(self):
+        self.assertEqual(
+            dumps(
+                {
+                    'datetime': DateTime(2025, 1, 1, 12, 0, 0),
+                    'nan_value': float('NaN'),
+                    'big_int': 123456789012345678901234567890,
+                },
+                **self.params,
+            ),
+            '{"big_int":123456789012345678901234567890,"datetime":{"__datetime__":"2025-01-01T12:00:00+00:00"},"nan_value":null}',
+        )
+
+    def test_datetime(self):
+        self.assertEqual(
+            dumps(DateTime(2025, 1, 1, 12, 0, 0), **self.params), '{"__datetime__":"2025-01-01T12:00:00+00:00"}'
+        )
+
+    def test_datetime_with_format(self):
+        self.assertEqual(
+            dumps(DateTime(2025, 1, 1, 12, 0, 0), datetime_format='%Y-%m-%d %H:%M:%S', **self.params),
+            '"2025-01-01 12:00:00"',
+        )
+
+    ## Objects
+    def test_base_object(self):
+        self.assertEqual(
+            dumps(BaseObject(a=1, b=2), **self.params),
+            '{"__class_path__":"everysk.core.object.BaseObject","_errors":null,"_is_frozen":false,"_silent":false,"a":1,"b":2}',
+        )
+
+    def test_base_object_without_class_path(self):
+        self.assertEqual(dumps(BaseObject(a=1, b=2), add_class_path=False, **self.params), '{"a":1,"b":2}')
+
+    def test_base_dict(self):
+        self.assertEqual(
+            dumps(BaseDict(a=1, b=2), **self.params),
+            '{"__class_path__":"everysk.core.object.BaseDict","_errors":null,"_is_frozen":false,"_silent":false,"a":1,"b":2}',
+        )
+
+    def test_base_dict_without_class_path(self):
+        self.assertEqual(dumps(BaseDict(a=1, b=2), add_class_path=False, **self.params), '{"a":1,"b":2}')
+
+    def test_dict_subclass_default(self):
+        # This use default dict serializer
+        self.assertEqual(dumps(MyDict(a=1, b=2), **self.params), '{"a":1,"b":2}')
+
+    def test_dict_subclass_passthrough(self):
+        # This will raise a TypeError because MyDict is not implemented
+        # to be serializable inside the JSONEncoder class
+        self.assertRaises(TypeError, dumps, MyDict(a=1, b=2), passthrough_subclass=True, **self.params)
+
+    def test_dict_key_non_str(self):
+        self.assertEqual(dumps({1: 'a', 1.1: 'b'}), '{"1": "a", "1.1": "b"}')
+
+    def test_return_str(self):
+        self.assertEqual(dumps('string', protocol='orjson', return_type='str'), '"string"')
+
+    def test_return_bytes(self):
+        self.assertEqual(dumps('string', protocol='orjson', return_type='bytes'), b'"string"')
+
+
+class SerializeOrjsonLoadsTestCase(TestCase):
+    def setUp(self):
+        self.params: dict = {'protocol': 'orjson'}
+
+    ## Constants
+    def test_null(self):
+        self.assertEqual(loads(b'null', **self.params), None)
+
+    def test_undefined_true(self):
+        self.assertEqual(loads(b'{"__undefined__":null}', use_undefined=True, **self.params), Undefined)
+
+    def test_undefined_false(self):
+        self.assertEqual(loads(b'{"__undefined__":null}', use_undefined=False, **self.params), None)
+
+    def test_nan(self):
+        self.assertIsNone(loads('NaN', **self.params))
+        self.assertRaises(JSONDecodeError, loads, 'NaN', nan_as_null=False, **self.params)
+
+    def test_infinity(self):
+        self.assertIsNone(loads('Infinity', **self.params))
+        self.assertRaises(JSONDecodeError, loads, 'Infinity', nan_as_null=False, **self.params)
+
+    def test_minus_infinity(self):
+        self.assertIsNone(loads('-Infinity', **self.params))
+        self.assertRaises(JSONDecodeError, loads, '-Infinity', nan_as_null=False, **self.params)
+
+    def test_big_int(self):
+        self.assertEqual(loads(b'123456789012345678901234567890', **self.params), 123456789012345678901234567890)
+
+    ## Basic types
+    def test_str(self):
+        self.assertEqual(loads(b'"teste"', **self.params), 'teste')
+
+    def test_bytes(self):
+        self.assertEqual(loads(b'{"__bytes__":{"encoding":"utf-8","value":"teste"}}', **self.params), b'teste')
+
+    def test_bytes_base64(self):
+        with open(PDF_PATH, 'rb') as fd:
+            data = fd.read()
+
+        self.assertEqual(
+            loads((f'{{"key":{{"__bytes__":{{"encoding":"base64","value":"{PDF}"}}}}}}').encode(), **self.params),
+            {'key': data},
+        )
+
+    def test_int(self):
+        self.assertEqual(loads(b'1', **self.params), 1)
+
+    def test_float(self):
+        self.assertEqual(loads(b'1.0', **self.params), 1.0)
+
+    def test_true(self):
+        self.assertEqual(loads(b'true', **self.params), True)
+
+    def test_false(self):
+        self.assertEqual(loads(b'false', **self.params), False)
+
+    def test_list(self):
+        self.assertEqual(loads(b'[2,"a",true]', **self.params), [2, 'a', True])
+
+    def test_dict(self):
+        self.assertEqual(loads(b'{"a":1,"2":"b"}', **self.params), {'a': 1, '2': 'b'})
+
+    def test_datetime_big_int_nan(self):
+        self.assertEqual(
+            loads(
+                b'{"big_int":123456789012345678901234567890,"datetime":{"__datetime__":"2025-01-01T12:00:00+00:00"},"nan_value":null}',
+                **self.params,
+            ),
+            {'big_int': 123456789012345678901234567890, 'datetime': DateTime(2025, 1, 1, 12, 0, 0), 'nan_value': None},
+        )
+
+    def test_date(self):
+        self.assertEqual(loads(b'{"__date__":"2025-01-01"}', **self.params), Date(2025, 1, 1))
+
+    def test_datetime(self):
+        self.assertEqual(
+            loads(b'{"__datetime__":"2025-01-01T12:00:00+00:00"}', **self.params), DateTime(2025, 1, 1, 12, 0, 0)
+        )
+
+    ## Objects
+    def test_base_object(self):
+        # pylint: disable=protected-access
+        obj = loads(
+            b'{"__class_path__":"everysk.core.object.BaseObject","_errors":null,"_is_frozen":false,"_silent":false,"a":1,"b":2}',
+            **self.params,
+        )
+        self.assertEqual(obj.a, 1)
+        self.assertEqual(obj.b, 2)
+        self.assertEqual(obj._errors, None)
+        self.assertEqual(obj._is_frozen, False)
+        self.assertEqual(obj._silent, False)
+        self.assertEqual(obj.__class__.__name__, 'BaseObject')
+
+    def test_base_dict(self):
+        self.assertEqual(
+            loads(
+                b'{"__class_path__":"everysk.core.object.BaseDict","_errors":null,"_is_frozen":false,"_silent":false,"a":1,"b":2}',
+                **self.params,
+            ),
+            BaseDict(a=1, b=2),
+        )
+
+    def test_dict_subclass(self):
+        self.assertEqual(
+            loads(b'{"__class_path__":"everysk.core._tests.serialize.test_orjson.MyDict","a":1,"b":2}', **self.params),
+            MyDict(a=1, b=2),
+        )

everysk/core/_tests/serialize/test_pickle.py

@@ -0,0 +1,48 @@
+###############################################################################
+#
+# (C) Copyright 2025 EVERYSK TECHNOLOGIES
+#
+# This is an unpublished work containing confidential and proprietary
+# information of EVERYSK TECHNOLOGIES. Disclosure, use, or reproduction
+# without authorization of EVERYSK TECHNOLOGIES is prohibited.
+#
+###############################################################################
+from everysk.core.exceptions import SigningError
+from everysk.core.serialize import dumps, loads
+from everysk.core.unittests import TestCase, mock
+
+
+class SerializePickleDumpsTestCase(TestCase):
+
+    @mock.patch('os.environ', {'EVERYSK_SIGNING_KEY': 'test'})
+    def test_protocol_pickle(self):
+        self.assertEqual(
+            dumps(1, protocol='pickle'),
+            b'68cec7e4c81fe8571641ae3709d4f546841ec9b1:\x80\x04K\x01.'
+        )
+
+    @mock.patch('os.environ', {'EVERYSK_SIGNING_KEY': None})
+    def test_protocol_pickle_no_key(self):
+        self.assertEqual(
+            dumps(1, protocol='pickle'),
+            b'\x80\x04K\x01.'
+        )
+
+
+class SerializePickleLoadsTestCase(TestCase):
+
+    @mock.patch('os.environ', {'EVERYSK_SIGNING_KEY': 'test'})
+    def test_protocol_pickle(self):
+        self.assertEqual(
+            loads(b'68cec7e4c81fe8571641ae3709d4f546841ec9b1:\x80\x04K\x01.', protocol='pickle'),
+            1
+        )
+
+    @mock.patch('os.environ', {'EVERYSK_SIGNING_KEY': 'test_invalid'})
+    def test_protocol_pickle_invalid(self):
+        with self.assertRaisesRegex(SigningError, 'Error trying to unsign data.'):
+            loads(b'1dd5f31b5032a28d51025f46121b03ebe20f258a:\x80\x04\x95\x05\x00\x00\x00\x00\x00\x00\x00\x8c\x01k\x94.', protocol='pickle')
+
+    @mock.patch('os.environ', {'EVERYSK_SIGNING_KEY': ''})
+    def test_protocol_pickle_no_key(self):
+        self.assertEqual(loads(b'\x80\x04K\x01.', protocol='pickle'), 1)