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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
import unittest
from typing import List, Optional
from marshmallow_dataclass import dataclass
@dataclass
class GlobalA:
b: "GlobalB"
@dataclass
class GlobalB:
pass
@dataclass
class GlobalSelfRecursion:
related: "List[GlobalSelfRecursion]"
@dataclass
class GlobalRecursion:
related: "List[GlobalRecursion]"
@dataclass
class GlobalCyclicA:
b: "Optional[GlobalCyclicB]"
@dataclass
class GlobalCyclicB:
a: "Optional[GlobalCyclicA]"
class TestForwardReferences(unittest.TestCase):
def test_late_evaluated_types(self):
@dataclass
class MyData:
value: int
self.assertEqual(MyData(1), MyData.Schema().load(dict(value=1)))
def test_forward_references_for_basic_types(self):
@dataclass
class Person:
name: "str"
age: "int"
self.assertEqual(
Person("Jon", 25), Person.Schema().load(dict(name="Jon", age=25))
)
def test_global_forward_references(self):
self.assertEqual(GlobalA(GlobalB()), GlobalA.Schema().load(dict(b=dict())))
def test_global_self_recursive_type(self):
self.assertEqual(
GlobalSelfRecursion([GlobalSelfRecursion([])]),
GlobalSelfRecursion.Schema().load(dict(related=[dict(related=[])])),
)
def test_global_recursive_type(self):
self.assertEqual(
GlobalRecursion([GlobalRecursion([])]),
GlobalRecursion.Schema().load(dict(related=[dict(related=[])])),
)
def test_global_circular_reference(self):
self.assertEqual(
GlobalCyclicA(GlobalCyclicB(GlobalCyclicA(None))),
GlobalCyclicA.Schema().load(dict(b=dict(a=dict(b=None)))),
)
def test_local_self_recursive_type(self):
@dataclass
class LocalSelfRecursion:
related: "List[LocalSelfRecursion]"
self.assertEqual(
LocalSelfRecursion([LocalSelfRecursion([])]),
LocalSelfRecursion.Schema().load(dict(related=[dict(related=[])])),
)
def test_local_recursive_type(self):
@dataclass
class LocalRecursion:
related: "List[LocalRecursion]"
self.assertEqual(
LocalRecursion([LocalRecursion([])]),
LocalRecursion.Schema().load(dict(related=[dict(related=[])])),
)
def test_local_forward_references(self):
@dataclass
class LocalA:
b: "LocalB"
@dataclass
class LocalB:
pass
self.assertEqual(LocalA(LocalB()), LocalA.Schema().load(dict(b=dict())))
def test_name_collisions(self):
"""
This is one example about why you should not make local schemas
:return:
"""
def make_another_a():
@dataclass
class A:
d: int
A.Schema()
make_another_a()
@dataclass
class A:
c: int
A.Schema()
@dataclass
class B:
a: "A"
# with self.assertRaises(marshmallow.exceptions.ValidationError):
B.Schema().load(dict(a=dict(c=1)))
# marshmallow.exceptions.ValidationError:
# {'a': {'d': ['Missing data for required field.'], 'c': ['Unknown field.']}}
def test_locals_from_decoration_ns(self):
# Test that locals are picked-up at decoration-time rather
# than when the decorator is constructed.
@frozen_dataclass
class A:
b: "B"
@frozen_dataclass
class B:
x: int
assert A.Schema().load({"b": {"x": 42}}) == A(b=B(x=42))
frozen_dataclass = dataclass(frozen=True)
|
