ext-json: fixed tests and made the lib more consistent with orjson vs simplejson

rhodecode/lib/ext_json.py

@@ -1,83 +1,86 b''
 import datetime
 import decimal
 import functools
 # we keep simplejson for having dump functionality still
 # orjson doesn't support it
+import simplejson as sjson
+
 import orjson
-import simplejson
 import orjson as json
 
 
 from rhodecode.lib.datelib import is_aware
 from rhodecode.lib.str_utils import safe_str
 
 try:
     import rhodecode.translation
 except ImportError:
     rhodecode = None
 
 __all__ = ['json']
 
 
 def _obj_dump(obj):
     """
     Custom function for dumping objects to JSON, if obj has __json__ attribute
     or method defined it will be used for serialization
 
     :param obj:
     """
-
     # See "Date Time String Format" in the ECMA-262 specification.
     # some code borrowed from django 1.4
     if isinstance(obj, set):
         return list(obj)
     elif isinstance(obj, datetime.datetime):
         r = obj.isoformat()
         if isinstance(obj.microsecond, int):
             r = r[:23] + r[26:]
         if r.endswith('+00:00'):
             r = r[:-6] + 'Z'
         return r
     elif isinstance(obj, datetime.date):
         return obj.isoformat()
     elif isinstance(obj, datetime.time):
         if is_aware(obj):
             raise TypeError("Time-zone aware times are not JSON serializable")
         r = obj.isoformat()
         if isinstance(obj.microsecond, int):
             r = r[:12]
         return r
     elif hasattr(obj, '__json__'):
         if callable(obj.__json__):
             return obj.__json__()
         else:
             return obj.__json__
     elif isinstance(obj, decimal.Decimal):
         return str(obj)
     elif isinstance(obj, complex):
         return [obj.real, obj.imag]
     elif rhodecode and isinstance(obj, rhodecode.translation._LazyString):
         return obj.eval()
     else:
         raise TypeError(repr(obj) + " is not JSON serializable")
 
 
+sjson.dumps = functools.partial(sjson.dumps, default=_obj_dump)
+sjson.dump = functools.partial(sjson.dump, default=_obj_dump)
+
 json.dumps = functools.partial(json.dumps, default=_obj_dump, option=orjson.OPT_NON_STR_KEYS)
-json.dump = functools.partial(simplejson.dump, default=_obj_dump)
+json.dump = functools.partial(sjson.dump, default=_obj_dump)
 
 
 def formatted_json(*args, **kwargs):
     # alias for formatted json
     opts = orjson.OPT_NON_STR_KEYS | orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS
     return functools.partial(json.dumps, option=opts)(*args, **kwargs)
 
 
 def formatted_str_json(*args, **kwargs):
     opts = orjson.OPT_NON_STR_KEYS | orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS
     closure = functools.partial(json.dumps, option=opts)
     return safe_str(closure(*args, **kwargs))
 
 
 def str_json(*args, **kwargs):
     closure = functools.partial(json.dumps)
     return safe_str(closure(*args, **kwargs))

rhodecode/tests/lib/test_ext_json.py

@@ -1,166 +1,167 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
+import io
 import datetime
 import decimal
-import io
 import textwrap
 
 import pytest
 
-from rhodecode.lib.ext_json import json
-from rhodecode.lib.ext_json import formatted_json
+from rhodecode.lib import ext_json
 from rhodecode.translation import _, _pluralize
 
 
 class Timezone(datetime.tzinfo):
     def __init__(self, hours):
         self.hours = hours
 
     def utcoffset(self, unused_dt):
         return datetime.timedelta(hours=self.hours)
 
 
+class SerializableObject(object):
+    def __json__(self):
+        return 'foo'
+
+
 def test_dumps_set():
-    result = json.dumps(set((1, 2, 3)))
+    result = ext_json.json.dumps(set((1, 2, 3)))
     # We cannot infer what the order of result is going to be
-    result = json.loads(result)
+    result = ext_json.json.loads(result)
     assert isinstance(result, list)
     assert [1, 2, 3] == sorted(result)
 
 
 def test_dumps_decimal():
-    assert '"1.5"' == json.dumps(decimal.Decimal('1.5'))
+    assert b'"1.5"' == ext_json.json.dumps(decimal.Decimal('1.5'))
 
 
 def test_dumps_complex():
-    assert "[0.0, 1.0]" == json.dumps(1j)
-    assert "[1.0, 0.0]" == json.dumps(1 + 0j)
-    assert "[1.1, 1.2]" == json.dumps(1.1 + 1.2j)
+    assert b"[0.0,1.0]" == ext_json.json.dumps(1j)
+    assert b"[1.0,0.0]" == ext_json.json.dumps(1 + 0j)
+    assert b"[1.1,1.2]" == ext_json.json.dumps(1.1 + 1.2j)
 
 
 def test_dumps_object_with_json_method():
-    class SerializableObject(object):
-        def __json__(self):
-            return 'foo'
-
-    assert '"foo"' == json.dumps(SerializableObject())
+    assert '"foo"' == ext_json.str_json(SerializableObject())
 
 
 def test_dumps_object_with_json_attribute():
-    class SerializableObject(object):
-        __json__ = 'foo'
 
-    assert '"foo"' == json.dumps(SerializableObject())
+    assert '"foo"' == ext_json.str_json(SerializableObject())
 
 
 def test_dumps_time():
-    assert '"03:14:15.926"' == json.dumps(datetime.time(3, 14, 15, 926535))
+    assert '"03:14:15.926535"' == ext_json.str_json(datetime.time(3, 14, 15, 926535))
 
 
 def test_dumps_time_no_microseconds():
-    assert '"03:14:15"' == json.dumps(datetime.time(3, 14, 15))
+    assert '"03:14:15"' == ext_json.str_json(datetime.time(3, 14, 15))
 
 
 def test_dumps_time_with_timezone():
     with pytest.raises(TypeError) as excinfo:
-        json.dumps(datetime.time(3, 14, 15, 926535, Timezone(0)))
+        ext_json.json.dumps(datetime.time(3, 14, 15, 926535, Timezone(0)))
 
     error_msg = str(excinfo.value)
-    assert 'Time-zone aware times are not JSON serializable' in error_msg
+
+    assert 'timezone library is not supported' in error_msg
+    # only for simplejson
+    #assert 'Time-zone aware times are not JSON serializable' in error_msg
 
 
 def test_dumps_date():
-    assert '"1969-07-20"' == json.dumps(datetime.date(1969, 7, 20))
+    assert b'"1969-07-20"' == ext_json.json.dumps(datetime.date(1969, 7, 20))
 
 
 def test_dumps_datetime():
-    json_data = json.dumps(datetime.datetime(1969, 7, 20, 3, 14, 15, 926535))
-    assert '"1969-07-20T03:14:15.926"' == json_data
+    json_data = ext_json.json.dumps(datetime.datetime(1969, 7, 20, 3, 14, 15, 926535))
+    assert b'"1969-07-20T03:14:15.926535"' == json_data
 
 
 def test_dumps_datetime_no_microseconds():
-    json_data = json.dumps(datetime.datetime(1969, 7, 20, 3, 14, 15))
-    assert '"1969-07-20T03:14:15"' == json_data
+    json_data = ext_json.json.dumps(datetime.datetime(1969, 7, 20, 3, 14, 15))
+    assert b'"1969-07-20T03:14:15"' == json_data
 
 
 def test_dumps_datetime_with_utc_timezone():
-    json_data = json.dumps(
+    json_data = ext_json.json.dumps(
         datetime.datetime(1969, 7, 20, 3, 14, 15, 926535, Timezone(0)))
-    assert '"1969-07-20T03:14:15.926Z"' == json_data
+    assert b'"1969-07-20T03:14:15.926535+00:00"' == json_data
 
 
 def test_dumps_datetime_with_plus1_timezone():
-    json_data = json.dumps(
+    json_data = ext_json.json.dumps(
         datetime.datetime(1969, 7, 20, 3, 14, 15, 926535, Timezone(1)))
-    assert '"1969-07-20T03:14:15.926+01:00"' == json_data
+    assert b'"1969-07-20T03:14:15.926535+01:00"' == json_data
 
 
 def test_dumps_unserializable_class():
     unserializable_obj = object()
     with pytest.raises(TypeError) as excinfo:
-        json.dumps(unserializable_obj)
+        ext_json.json.dumps(unserializable_obj)
 
-    assert repr(unserializable_obj) in str(excinfo.value)
+    assert 'object' in str(excinfo.value)
     assert 'is not JSON serializable' in str(excinfo.value)
 
 
 def test_dump_is_like_dumps():
     data = {
         'decimal': decimal.Decimal('1.5'),
         'set': set([1]),  # Just one element to guarantee the order
         'complex': 1 - 1j,
         'datetime': datetime.datetime(1969, 7, 20, 3, 14, 15, 926535),
         'time': datetime.time(3, 14, 15, 926535),
         'date': datetime.date(1969, 7, 20),
     }
-    json_buffer = io.BytesIO()
-    json.dump(data, json_buffer)
+    json_buffer = io.StringIO()  # StringIO because dump uses simplejson not orjson
+    ext_json.json.dump(data, json_buffer)
 
-    assert json.dumps(data) == json_buffer.getvalue()
+    assert ext_json.sjson.dumps(data) == json_buffer.getvalue()
 
 
 def test_formatted_json():
     data = {
         'b': {'2': 2, '1': 1},
         'a': {'3': 3, '4': 4},
     }
 
     expected_data = textwrap.dedent('''
     {
-        "a": {
-            "3": 3,
-            "4": 4
-        },
-        "b": {
-            "1": 1,
-            "2": 2
-        }
+      "a": {
+        "3": 3,
+        "4": 4
+      },
+      "b": {
+        "1": 1,
+        "2": 2
+      }
     }''').strip()
 
-    assert formatted_json(data) == expected_data
+    assert expected_data == ext_json.formatted_str_json(data)
 
 
 def test_lazy_translation_string(baseapp):
     data = {'label': _('hello')}
     data2 = {'label2': _pluralize('singular', 'plural', 1)}
 
-    assert json.dumps(data) == '{"label": "hello"}'
-    assert json.dumps(data2) == '{"label2": "singular"}'
+    assert b'{"label":"hello"}' == ext_json.json.dumps(data)
+    assert b'{"label2":"singular"}' == ext_json.json.dumps(data2)