test

Author: ijl

.travis.yml

@@ -1,11 +1,10 @@
 dist: xenial
 language: python
 python:
-  - "3.5"
   - "3.6"
   - "3.7"
 install:
-  - pip install --upgrade pip wheel pyo3-pack pytest
+  - pip install --upgrade pip wheel pyo3-pack pytest hypothesis
   - curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightly -y
   - PATH=$HOME/.cargo/bin:$PATH cargo update
 script:

test/__init__.py

@@ -1 +0,0 @@
-

test/test_api.py

@@ -1,12 +1,55 @@
 # SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 import unittest
+import json
 
 import orjson
 
 
+SIMPLE_TYPES = (1, 1.0, -1, None, "str", True, False)
+
+
 class ApiTests(unittest.TestCase):
 
+    def test_loads_trailing(self):
+        """
+        loads() handles trailing whitespace
+        """
+        self.assertEqual(orjson.loads('{}\n\t '), {})
+
+    def test_loads_trailing_invalid(self):
+        """
+        loads() handles trailing invalid
+        """
+        self.assertRaises(orjson.JSONDecodeError, orjson.loads, '{}\n\t a')
+
+    def test_simple_json(self):
+        """
+        dumps() equivalent to json on simple types
+        """
+        for obj in SIMPLE_TYPES:
+            self.assertEqual(orjson.dumps(obj), json.dumps(obj).encode('utf-8'))
+
+    def test_simple_round_trip(self):
+        """
+        dumps(), loads() round trip on simple types
+        """
+        for obj in SIMPLE_TYPES:
+            self.assertEqual(orjson.loads(orjson.dumps(obj)), obj)
+
+    def test_loads_type(self):
+        """
+        loads() invalid type
+        """
+        for val in (1, 3.14, [], {}, None):
+            self.assertRaises(TypeError, orjson.loads, val)
+
+    def test_loads_recursion(self):
+        """
+        loads() recursion limit
+        """
+        self.assertRaises(orjson.JSONDecodeError, orjson.loads, '[' * (1024 * 1024))
+
     def test_version(self):
         """
         __version__

test/test_fixture.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import json
+import lzma
+import os
+import unittest
+
+import orjson
+
+
+dirname = os.path.dirname(__file__)
+
+
+def fixture_fileh(filename):
+    return lzma.open(os.path.join(dirname, '../data', filename), 'r')
+
+
+def read_fixture(filename):
+    with fixture_fileh(filename) as fileh:
+        return fileh.read().decode('utf-8')
+
+
+class FixtureTests(unittest.TestCase):
+
+    def test_twitter(self):
+        """
+        loads(),dumps() twitter.json
+        """
+        val = read_fixture('twitter.json.xz')
+        read = json.loads(val)
+        orjson.dumps(read)
+
+    def test_canada(self):
+        """
+        loads(), dumps() canada.json
+        """
+        val = read_fixture('canada.json.xz')
+        read = orjson.loads(val)
+        orjson.dumps(read)
+
+    def test_citm_catalog(self):
+        """
+        loads(), dumps() citm_catalog.json
+        """
+        val = read_fixture('citm_catalog.json.xz')
+        read = orjson.loads(val)
+        orjson.dumps(read)
+
+    def test_blns(self):
+        """
+        loads() blns.json JSONDecodeError
+
+        https://github.com/minimaxir/big-list-of-naughty-strings
+        """
+        val = read_fixture('blns.json.xz')
+        with self.assertRaises(json.decoder.JSONDecodeError):
+            _ = orjson.loads(val)

test/test_hypothesis.py

@@ -0,0 +1,61 @@
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import pytest
+from hypothesis import given, strategies as st
+
+import orjson
+
+
+# min, max: RFC 7159
+st_int = st.integers(min_value=-(2**53)+1, max_value=(2**53)-1)
+st_floats = st.floats(min_value=-(2**53)+1, max_value=(2**53)-1)
+
+# st.floats would be nice, but then we need pytest.approx, which doesn't work with eg. text
+st_json = st.recursive(st.booleans() | st.none() | st_int  # | st_floats  # st.text() |
+                       , lambda children: st.lists(children) | st.dictionaries(st.text(), children))
+
+
+@given(st_floats)
+def test_floats(xs):
+    assert orjson.loads(orjson.dumps(xs)) == pytest.approx(
+        xs)  # fails when abs=0.05
+
+
+@given(st.text())
+def test_text(xs):
+    assert orjson.loads(orjson.dumps(xs)) == xs
+
+
+@given(st.booleans())
+def test_bool(xs):
+    assert orjson.loads(orjson.dumps(xs)) == xs
+
+
+@given(st.none())
+def test_none(xs):
+    assert orjson.loads(orjson.dumps(xs)) == xs
+
+
+@given(st.lists(st_int))
+def test_list_integers(lst):
+    assert orjson.loads(orjson.dumps(lst)) == lst
+
+
+@given(st.lists(st.floats(min_value=-(2**53)+1, max_value=(2**53)-1)))
+def test_list_floats(lst):
+    assert orjson.loads(orjson.dumps(lst)) == pytest.approx(lst)
+
+
+@given(st.lists(st.text()))
+def test_list_text(lst):
+    assert orjson.loads(orjson.dumps(lst)) == lst
+
+
+@given(st.lists(st.one_of(st_int, st_floats)))
+def test_list_mixed(lst):
+    assert orjson.loads(orjson.dumps(lst)) == pytest.approx(lst)
+
+
+@given(st_json)
+def test_json_obj(j_obj):
+    assert orjson.loads(orjson.dumps(j_obj)) == j_obj