orjson/test/test_subclass.py at master · ITCSsDeveloper/orjson · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
# SPDX-License-Identifier: (Apache-2.0 OR MIT)

import collections
import json
import unittest

import orjson


class SubStr(str):
    pass


class SubInt(int):
    pass


class SubDict(dict):
    pass


class SubList(list):
    pass


class SubFloat(float):
    pass


class SubTuple(tuple):
    pass


class SubclassTests(unittest.TestCase):
    def test_subclass_str(self):
        self.assertEqual(
            orjson.dumps(SubStr("zxc")),
            b'"zxc"',
        )

    def test_subclass_str_invalid(self):
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(SubStr("\ud800"))

    def test_subclass_int(self):
        self.assertEqual(orjson.dumps(SubInt(1)), b"1")

    def test_subclass_int_64(self):
        for val in (9223372036854775807, -9223372036854775807):
            self.assertEqual(orjson.dumps(SubInt(val)), str(val).encode("utf-8"))

    def test_subclass_int_53(self):
        for val in (9007199254740992, -9007199254740992):
            with self.assertRaises(orjson.JSONEncodeError):
                orjson.dumps(SubInt(val), option=orjson.OPT_STRICT_INTEGER)

    def test_subclass_dict(self):
        self.assertEqual(
            orjson.dumps(SubDict({"a": "b"})),
            b'{"a":"b"}',
        )

    def test_subclass_list(self):
        self.assertEqual(
            orjson.dumps(SubList(["a", "b"])),
            b'["a","b"]',
        )
        ref = [True] * 512
        self.assertEqual(orjson.loads(orjson.dumps(SubList(ref))), ref)

    def test_subclass_float(self):
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(SubFloat(1.1))
        self.assertEqual(
            json.dumps(SubFloat(1.1)),
            "1.1",
        )

    def test_subclass_tuple(self):
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(SubTuple((1, 2)))
        self.assertEqual(
            json.dumps(SubTuple((1, 2))),
            "[1, 2]",
        )

    def test_namedtuple(self):
        Point = collections.namedtuple("Point", ["x", "y"])
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(Point(1, 2))

    def test_subclass_circular_dict(self):
        obj = SubDict({})
        obj["obj"] = obj
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(obj)

    def test_subclass_circular_list(self):
        obj = SubList([])
        obj.append(obj)
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(obj)

    def test_subclass_circular_nested(self):
        obj = SubDict({})
        obj["list"] = SubList([{"obj": obj}])
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(obj)


class SubclassPassthroughTests(unittest.TestCase):
    def test_subclass_str(self):
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(SubStr("zxc"), option=orjson.OPT_PASSTHROUGH_SUBCLASS)

    def test_subclass_int(self):
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(SubInt(1), option=orjson.OPT_PASSTHROUGH_SUBCLASS)

    def test_subclass_dict(self):
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(SubDict({"a": "b"}), option=orjson.OPT_PASSTHROUGH_SUBCLASS)

    def test_subclass_list(self):
        with self.assertRaises(orjson.JSONEncodeError):
            orjson.dumps(SubList(["a", "b"]), option=orjson.OPT_PASSTHROUGH_SUBCLASS)