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
|
"""Tests for josepy.interfaces."""
import sys
import unittest
from typing import Any, Dict, List
import pytest
class JSONDeSerializableTest(unittest.TestCase):
def setUp(self) -> None:
from josepy.interfaces import JSONDeSerializable
class Basic(JSONDeSerializable):
def __init__(self, v: Any) -> None:
self.v = v
def to_partial_json(self) -> Any:
return self.v
@classmethod
def from_json(cls, jobj: Any) -> "Basic":
return cls(jobj)
class Sequence(JSONDeSerializable):
def __init__(self, x: Basic, y: Basic) -> None:
self.x = x
self.y = y
def to_partial_json(self) -> List[Basic]:
return [self.x, self.y]
@classmethod
def from_json(cls, jobj: List[Any]) -> "Sequence":
return cls(Basic.from_json(jobj[0]), Basic.from_json(jobj[1]))
class Mapping(JSONDeSerializable):
def __init__(self, x: Any, y: Any) -> None:
self.x = x
self.y = y
def to_partial_json(self) -> Dict[Basic, Basic]:
return {self.x: self.y}
@classmethod
def from_json(cls, jobj: Any) -> "Mapping":
return cls("dummy", "values") # pragma: no cover
self.basic1 = Basic("foo1")
self.basic2 = Basic("foo2")
self.seq = Sequence(self.basic1, self.basic2)
self.mapping = Mapping(self.basic1, self.basic2)
self.nested = Basic([[self.basic1]])
self.tuple = Basic(("foo",))
self.Basic = Basic
self.Sequence = Sequence
self.Mapping = Mapping
def test_to_json_sequence(self) -> None:
assert self.seq.to_json() == ["foo1", "foo2"]
def test_to_json_mapping(self) -> None:
assert self.mapping.to_json() == {"foo1": "foo2"}
def test_to_json_other(self) -> None:
mock_value = object()
assert self.Basic(mock_value).to_json() is mock_value
def test_to_json_nested(self) -> None:
assert self.nested.to_json() == [["foo1"]]
def test_to_json(self) -> None:
assert self.tuple.to_json() == (("foo",))
def test_from_json_not_implemented(self) -> None:
from josepy.interfaces import JSONDeSerializable
with pytest.raises(TypeError):
JSONDeSerializable.from_json("xxx")
def test_json_loads(self) -> None:
seq = self.Sequence.json_loads('["foo1", "foo2"]')
assert isinstance(seq, self.Sequence)
assert isinstance(seq.x, self.Basic)
assert isinstance(seq.y, self.Basic)
assert seq.x.v == "foo1"
assert seq.y.v == "foo2"
def test_json_dumps(self) -> None:
assert '["foo1", "foo2"]' == self.seq.json_dumps()
def test_json_dumps_pretty(self) -> None:
assert self.seq.json_dumps_pretty() == '[\n "foo1",\n "foo2"\n]'
def test_json_dump_default(self) -> None:
from josepy.interfaces import JSONDeSerializable
assert "foo1" == JSONDeSerializable.json_dump_default(self.basic1)
jobj = JSONDeSerializable.json_dump_default(self.seq)
assert len(jobj) == 2
assert jobj[0] is self.basic1
assert jobj[1] is self.basic2
def test_json_dump_default_type_error(self) -> None:
from josepy.interfaces import JSONDeSerializable
with pytest.raises(TypeError):
# We're purposefully testing with the incorrect type here.
JSONDeSerializable.json_dump_default(object()) # type: ignore
if __name__ == "__main__":
sys.exit(pytest.main(sys.argv[1:] + [__file__])) # pragma: no cover
|
