Coverage for tests/test_jsonable_encoder.py: 100%

1from collections import deque 5 ctx1abcde

2from dataclasses import dataclass 5 ctx1abcde

3from datetime import datetime, timezone 5 ctx1abcde

4from decimal import Decimal 5 ctx1abcde

5from enum import Enum 5 ctx1abcde

6from pathlib import PurePath, PurePosixPath, PureWindowsPath 5 ctx1abcde

7from typing import Optional 5 ctx1abcde

8 

9import pytest 5 ctx1abcde

10from fastapi._compat import PYDANTIC_V2, Undefined 5 ctx1abcde

11from fastapi.encoders import jsonable_encoder 5 ctx1abcde

12from pydantic import BaseModel, Field, ValidationError 5 ctx1abcde

13 

14from .utils import needs_pydanticv1, needs_pydanticv2 5 ctx1abcde

15 

16 

17class Person: 5 ctx1abcde

18 def __init__(self, name: str): 5 ctx1abcde

19 self.name = name 10 ctx1ufvgwhxiyj

20 

21 

22class Pet: 5 ctx1abcde

23 def __init__(self, owner: Person, name: str): 5 ctx1abcde

24 self.owner = owner 10 ctx1ufvgwhxiyj

25 self.name = name 10 ctx1ufvgwhxiyj

26 

27 

28@dataclass 5 ctx1abcde

29class Item: 5 ctx1abcde

30 name: str 5 ctx1abcde

31 count: int 5 ctx1abcde

32 

33 

34class DictablePerson(Person): 5 ctx1abcde

35 def __iter__(self): 5 ctx1abcde

36 return ((k, v) for k, v in self.__dict__.items()) 5 ctx1fghij

37 

38 

39class DictablePet(Pet): 5 ctx1abcde

40 def __iter__(self): 5 ctx1abcde

41 return ((k, v) for k, v in self.__dict__.items()) 5 ctx1fghij

42 

43 

44class Unserializable: 5 ctx1abcde

45 def __iter__(self): 5 ctx1abcde

46 raise NotImplementedError() 5 ctx1%'()*

47 

48 @property 5 ctx1abcde

49 def __dict__(self): 5 ctx1abcde

50 raise NotImplementedError() 5 ctx1%'()*

51 

52 

53class RoleEnum(Enum): 5 ctx1abcde

54 admin = "admin" 5 ctx1abcde

55 normal = "normal" 5 ctx1abcde

56 

57 

58class ModelWithConfig(BaseModel): 5 ctx1abcde

59 role: Optional[RoleEnum] = None 5 ctx1abcde

60 

61 if PYDANTIC_V2: 5 ctx1abcde

62 model_config = {"use_enum_values": True} 5 ctx1abcde

63 else: 

64 

65 class Config: 5 ctx1abcde

66 use_enum_values = True 5 ctx1abcde

67 

68 

69class ModelWithAlias(BaseModel): 5 ctx1abcde

70 foo: str = Field(alias="Foo") 5 ctx1abcde

71 

72 

73class ModelWithDefault(BaseModel): 5 ctx1abcde

74 foo: str = ... # type: ignore 5 ctx1abcde

75 bar: str = "bar" 5 ctx1abcde

76 bla: str = "bla" 5 ctx1abcde

77 

78 

79def test_encode_dict(): 5 ctx1abcde

80 pet = {"name": "Firulais", "owner": {"name": "Foo"}} 5 ctx134567

81 assert jsonable_encoder(pet) == {"name": "Firulais", "owner": {"name": "Foo"}} 5 ctx134567

82 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 5 ctx134567

83 assert jsonable_encoder(pet, exclude={"owner"}) == {"name": "Firulais"} 5 ctx134567

84 assert jsonable_encoder(pet, include={}) == {} 5 ctx134567

85 assert jsonable_encoder(pet, exclude={}) == { 5 ctx134567

86 "name": "Firulais", 

87 "owner": {"name": "Foo"}, 

88 } 

89 

90 

91def test_encode_class(): 5 ctx1abcde

92 person = Person(name="Foo") 5 ctx1uvwxy

93 pet = Pet(owner=person, name="Firulais") 5 ctx1uvwxy

94 assert jsonable_encoder(pet) == {"name": "Firulais", "owner": {"name": "Foo"}} 5 ctx1uvwxy

95 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 5 ctx1uvwxy

96 assert jsonable_encoder(pet, exclude={"owner"}) == {"name": "Firulais"} 5 ctx1uvwxy

97 assert jsonable_encoder(pet, include={}) == {} 5 ctx1uvwxy

98 assert jsonable_encoder(pet, exclude={}) == { 5 ctx1uvwxy

99 "name": "Firulais", 

100 "owner": {"name": "Foo"}, 

101 } 

102 

103 

104def test_encode_dictable(): 5 ctx1abcde

105 person = DictablePerson(name="Foo") 5 ctx1fghij

106 pet = DictablePet(owner=person, name="Firulais") 5 ctx1fghij

107 assert jsonable_encoder(pet) == {"name": "Firulais", "owner": {"name": "Foo"}} 5 ctx1fghij

108 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 5 ctx1fghij

109 assert jsonable_encoder(pet, exclude={"owner"}) == {"name": "Firulais"} 5 ctx1fghij

110 assert jsonable_encoder(pet, include={}) == {} 5 ctx1fghij

111 assert jsonable_encoder(pet, exclude={}) == { 5 ctx1fghij

112 "name": "Firulais", 

113 "owner": {"name": "Foo"}, 

114 } 

115 

116 

117def test_encode_dataclass(): 5 ctx1abcde

118 item = Item(name="foo", count=100) 5 ctx189!#$

119 assert jsonable_encoder(item) == {"name": "foo", "count": 100} 5 ctx189!#$

120 assert jsonable_encoder(item, include={"name"}) == {"name": "foo"} 5 ctx189!#$

121 assert jsonable_encoder(item, exclude={"count"}) == {"name": "foo"} 5 ctx189!#$

122 assert jsonable_encoder(item, include={}) == {} 5 ctx189!#$

123 assert jsonable_encoder(item, exclude={}) == {"name": "foo", "count": 100} 5 ctx189!#$

124 

125 

126def test_encode_unsupported(): 5 ctx1abcde

127 unserializable = Unserializable() 5 ctx1%'()*

128 with pytest.raises(ValueError): 5 ctx1%'()*

129 jsonable_encoder(unserializable) 5 ctx1%'()*

130 

131 

132@needs_pydanticv2 5 ctx1abcde

133def test_encode_custom_json_encoders_model_pydanticv2(): 5 ctx1abcde

134 from pydantic import field_serializer 5 ctx1klmno

135 

136 class ModelWithCustomEncoder(BaseModel): 5 ctx1klmno

137 dt_field: datetime 5 ctx1klmno

138 

139 @field_serializer("dt_field") 5 ctx1klmno

140 def serialize_dt_field(self, dt): 5 ctx1klmno

141 return dt.replace(microsecond=0, tzinfo=timezone.utc).isoformat() 5 ctx1klmno

142 

143 class ModelWithCustomEncoderSubclass(ModelWithCustomEncoder): 5 ctx1klmno

144 pass 5 ctx1klmno

145 

146 model = ModelWithCustomEncoder(dt_field=datetime(2019, 1, 1, 8)) 5 ctx1klmno

147 assert jsonable_encoder(model) == {"dt_field": "2019-01-01T08:00:00+00:00"} 5 ctx1klmno

148 subclass_model = ModelWithCustomEncoderSubclass(dt_field=datetime(2019, 1, 1, 8)) 5 ctx1klmno

149 assert jsonable_encoder(subclass_model) == {"dt_field": "2019-01-01T08:00:00+00:00"} 5 ctx1klmno

150 

151 

152# TODO: remove when deprecating Pydantic v1 

153@needs_pydanticv1 5 ctx1abcde

154def test_encode_custom_json_encoders_model_pydanticv1(): 5 ctx1abcde

155 class ModelWithCustomEncoder(BaseModel): 5 ctx1pqrst

156 dt_field: datetime 5 ctx1pqrst

157 

158 class Config: 5 ctx1pqrst

159 json_encoders = { 5 ctx1pqrst

160 datetime: lambda dt: dt.replace( 

161 microsecond=0, tzinfo=timezone.utc 

162 ).isoformat() 

163 } 

164 

165 class ModelWithCustomEncoderSubclass(ModelWithCustomEncoder): 5 ctx1pqrst

166 class Config: 5 ctx1pqrst

167 pass 5 ctx1pqrst

168 

169 model = ModelWithCustomEncoder(dt_field=datetime(2019, 1, 1, 8)) 5 ctx1pqrst

170 assert jsonable_encoder(model) == {"dt_field": "2019-01-01T08:00:00+00:00"} 5 ctx1pqrst

171 subclass_model = ModelWithCustomEncoderSubclass(dt_field=datetime(2019, 1, 1, 8)) 5 ctx1pqrst

172 assert jsonable_encoder(subclass_model) == {"dt_field": "2019-01-01T08:00:00+00:00"} 5 ctx1pqrst

173 

174 

175def test_encode_model_with_config(): 5 ctx1abcde

176 model = ModelWithConfig(role=RoleEnum.admin) 5 ctx1[]^_`

177 assert jsonable_encoder(model) == {"role": "admin"} 5 ctx1[]^_`

178 

179 

180def test_encode_model_with_alias_raises(): 5 ctx1abcde

181 with pytest.raises(ValidationError): 5 ctx2{ | } ~ ab

182 ModelWithAlias(foo="Bar") 5 ctx2{ | } ~ ab

183 

184 

185def test_encode_model_with_alias(): 5 ctx1abcde

186 model = ModelWithAlias(Foo="Bar") 5 ctx2bbcbdbebfb

187 assert jsonable_encoder(model) == {"Foo": "Bar"} 5 ctx2bbcbdbebfb

188 

189 

190def test_encode_model_with_default(): 5 ctx1abcde

191 model = ModelWithDefault(foo="foo", bar="bar") 5 ctx1zABCD

192 assert jsonable_encoder(model) == {"foo": "foo", "bar": "bar", "bla": "bla"} 5 ctx1zABCD

193 assert jsonable_encoder(model, exclude_unset=True) == {"foo": "foo", "bar": "bar"} 5 ctx1zABCD

194 assert jsonable_encoder(model, exclude_defaults=True) == {"foo": "foo"} 5 ctx1zABCD

195 assert jsonable_encoder(model, exclude_unset=True, exclude_defaults=True) == { 5 ctx1zABCD

196 "foo": "foo" 

197 } 

198 assert jsonable_encoder(model, include={"foo"}) == {"foo": "foo"} 5 ctx1zABCD

199 assert jsonable_encoder(model, exclude={"bla"}) == {"foo": "foo", "bar": "bar"} 5 ctx1zABCD

200 assert jsonable_encoder(model, include={}) == {} 5 ctx1zABCD

201 assert jsonable_encoder(model, exclude={}) == { 5 ctx1zABCD

202 "foo": "foo", 

203 "bar": "bar", 

204 "bla": "bla", 

205 } 

206 

207 

208@needs_pydanticv1 5 ctx1abcde

209def test_custom_encoders(): 5 ctx1abcde

210 class safe_datetime(datetime): 5 ctx1TUVWX

211 pass 5 ctx1TUVWX

212 

213 class MyModel(BaseModel): 5 ctx1TUVWX

214 dt_field: safe_datetime 5 ctx1TUVWX

215 

216 instance = MyModel(dt_field=safe_datetime.now()) 5 ctx1TUVWX

217 

218 encoded_instance = jsonable_encoder( 5 ctx1TUVWX

219 instance, custom_encoder={safe_datetime: lambda o: o.isoformat()} 

220 ) 

221 assert encoded_instance["dt_field"] == instance.dt_field.isoformat() 5 ctx1TUVWX

222 

223 

224def test_custom_enum_encoders(): 5 ctx1abcde

225 def custom_enum_encoder(v: Enum): 5 ctx1YZ012

226 return v.value.lower() 5 ctx1YZ012

227 

228 class MyEnum(Enum): 5 ctx1YZ012

229 ENUM_VAL_1 = "ENUM_VAL_1" 5 ctx1YZ012

230 

231 instance = MyEnum.ENUM_VAL_1 5 ctx1YZ012

232 

233 encoded_instance = jsonable_encoder( 5 ctx1YZ012

234 instance, custom_encoder={MyEnum: custom_enum_encoder} 

235 ) 

236 assert encoded_instance == custom_enum_encoder(instance) 5 ctx1YZ012

237 

238 

239def test_encode_model_with_pure_path(): 5 ctx1abcde

240 class ModelWithPath(BaseModel): 5 ctx1EFGHI

241 path: PurePath 5 ctx1EFGHI

242 

243 if PYDANTIC_V2: 5 ctx1EFGHI

244 model_config = {"arbitrary_types_allowed": True} 5 ctx1EFGHI

245 else: 

246 

247 class Config: 5 ctx1EFGHI

248 arbitrary_types_allowed = True 5 ctx1EFGHI

249 

250 test_path = PurePath("/foo", "bar") 5 ctx1EFGHI

251 obj = ModelWithPath(path=test_path) 5 ctx1EFGHI

252 assert jsonable_encoder(obj) == {"path": str(test_path)} 5 ctx1EFGHI

253 

254 

255def test_encode_model_with_pure_posix_path(): 5 ctx1abcde

256 class ModelWithPath(BaseModel): 5 ctx1JKLMN

257 path: PurePosixPath 5 ctx1JKLMN

258 

259 if PYDANTIC_V2: 5 ctx1JKLMN

260 model_config = {"arbitrary_types_allowed": True} 5 ctx1JKLMN

261 else: 

262 

263 class Config: 5 ctx1JKLMN

264 arbitrary_types_allowed = True 5 ctx1JKLMN

265 

266 obj = ModelWithPath(path=PurePosixPath("/foo", "bar")) 5 ctx1JKLMN

267 assert jsonable_encoder(obj) == {"path": "/foo/bar"} 5 ctx1JKLMN

268 

269 

270def test_encode_model_with_pure_windows_path(): 5 ctx1abcde

271 class ModelWithPath(BaseModel): 5 ctx1OPQRS

272 path: PureWindowsPath 5 ctx1OPQRS

273 

274 if PYDANTIC_V2: 5 ctx1OPQRS

275 model_config = {"arbitrary_types_allowed": True} 5 ctx1OPQRS

276 else: 

277 

278 class Config: 5 ctx1OPQRS

279 arbitrary_types_allowed = True 5 ctx1OPQRS

280 

281 obj = ModelWithPath(path=PureWindowsPath("/foo", "bar")) 5 ctx1OPQRS

282 assert jsonable_encoder(obj) == {"path": "\\foo\\bar"} 5 ctx1OPQRS

283 

284 

285@needs_pydanticv1 5 ctx1abcde

286def test_encode_root(): 5 ctx1abcde

287 class ModelWithRoot(BaseModel): 5 ctx1+,-./

288 __root__: str 5 ctx1+,-./

289 

290 model = ModelWithRoot(__root__="Foo") 5 ctx1+,-./

291 assert jsonable_encoder(model) == "Foo" 5 ctx1+,-./

292 

293 

294@needs_pydanticv2 5 ctx1abcde

295def test_decimal_encoder_float(): 5 ctx1abcde

296 data = {"value": Decimal(1.23)} 5 ctx2gbhbibjbkb

297 assert jsonable_encoder(data) == {"value": 1.23} 5 ctx2gbhbibjbkb

298 

299 

300@needs_pydanticv2 5 ctx1abcde

301def test_decimal_encoder_int(): 5 ctx1abcde

302 data = {"value": Decimal(2)} 5 ctx2lbmbnbobpb

303 assert jsonable_encoder(data) == {"value": 2} 5 ctx2lbmbnbobpb

304 

305 

306def test_encode_deque_encodes_child_models(): 5 ctx1abcde

307 class Model(BaseModel): 5 ctx1:;=?@

308 test: str 5 ctx1:;=?@

309 

310 dq = deque([Model(test="test")]) 5 ctx1:;=?@

311 

312 assert jsonable_encoder(dq)[0]["test"] == "test" 5 ctx1:;=?@

313 

314 

315@needs_pydanticv2 5 ctx1abcde

316def test_encode_pydantic_undefined(): 5 ctx1abcde

317 data = {"value": Undefined} 5 ctx2qbrbsbtbub

318 assert jsonable_encoder(data) == {"value": None} 5 ctx2qbrbsbtbub