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
152
153
|
from dataclasses import dataclass, field
import pytest
from graphql import graphql_sync, print_schema
from apischema import deserialize, serialize
from apischema.graphql import graphql_schema
from apischema.json_schema import deserialization_schema, serialization_schema
from apischema.metadata import conversion, flatten
from apischema.objects import ObjectField, set_object_fields
class Field:
def __init__(self, attr: int):
self.attr = attr
set_object_fields(Field, [ObjectField("attr", int)])
@dataclass
class Data:
data_field: Field = field(metadata=flatten)
def get_data() -> Data:
return Data(Field(0))
def test_flattened_dataclass_model():
data = deserialize(Data, {"attr": 0})
assert isinstance(data.data_field, Field) and data.data_field.attr == 0
assert serialize(Data, data) == {"attr": 0}
assert (
deserialization_schema(Data)
== serialization_schema(Data)
== {
"$schema": "http://json-schema.org/draft/2020-12/schema#",
"allOf": [
{"type": "object", "additionalProperties": False},
{
"type": "object",
"properties": {"attr": {"type": "integer"}},
"required": ["attr"],
"additionalProperties": False,
},
],
"unevaluatedProperties": False,
}
)
schema = graphql_schema(query=[get_data])
assert graphql_sync(schema, "{getData{attr}}").data == {"getData": {"attr": 0}}
assert (
print_schema(schema)
== """\
type Query {
getData: Data!
}
type Data {
attr: Int!
}"""
)
class Field2:
def __init__(self, attr: int):
self.attr = attr
@staticmethod
def from_field(field: Field) -> "Field2":
return Field2(field.attr)
def to_field(self) -> Field:
return Field(self.attr)
@staticmethod
def from_int(i: int) -> "Field2":
return Field2(i)
def to_int(self) -> int:
return self.attr
@dataclass
class Data2:
data_field2: Field2 = field(
metadata=flatten | conversion(Field2.from_field, Field2.to_field)
)
def get_data2() -> Data2:
return Data2(Field2(0))
def test_flattened_converted():
data2 = deserialize(Data2, {"attr": 0})
assert isinstance(data2.data_field2, Field2) and data2.data_field2.attr == 0
assert serialize(Data2, data2) == {"attr": 0}
assert (
deserialization_schema(Data)
== serialization_schema(Data)
== {
"$schema": "http://json-schema.org/draft/2020-12/schema#",
"allOf": [
{"type": "object", "additionalProperties": False},
{
"type": "object",
"properties": {"attr": {"type": "integer"}},
"required": ["attr"],
"additionalProperties": False,
},
],
"unevaluatedProperties": False,
}
)
schema = graphql_schema(query=[get_data2])
assert graphql_sync(schema, "{getData2{attr}}").data == {"getData2": {"attr": 0}}
assert (
print_schema(schema)
== """\
type Query {
getData2: Data2!
}
type Data2 {
attr: Int!
}"""
)
@dataclass
class Data3:
data_field2: Field2 = field(
metadata=flatten | conversion(Field2.from_int, Field2.to_int)
)
def get_data3() -> Data3: # type: ignore
...
def test_flattened_converted_error():
with pytest.raises(TypeError):
deserialize(Data3, {"attr": 0})
with pytest.raises(TypeError):
serialize(Data3, Data3(Field2(0)))
with pytest.raises(TypeError):
deserialization_schema(Data3)
with pytest.raises(TypeError):
serialization_schema(Data3)
with pytest.raises(TypeError):
graphql_schema(query=[get_data3])
|
