Coverage for tests / test_jsonable_encoder.py: 100%

1import warnings 4 ctx1adbc

2from collections import deque 4 ctx1adbc

3from dataclasses import dataclass 4 ctx1adbc

4from datetime import datetime, timezone 4 ctx1adbc

5from decimal import Decimal 4 ctx1adbc

6from enum import Enum 4 ctx1adbc

7from math import isinf, isnan 4 ctx1adbc

8from pathlib import PurePath, PurePosixPath, PureWindowsPath 4 ctx1adbc

9from typing import TypedDict 4 ctx1adbc

10 

11import pytest 4 ctx1adbc

12from fastapi._compat import Undefined 4 ctx1adbc

13from fastapi.encoders import jsonable_encoder 4 ctx1adbc

14from fastapi.exceptions import PydanticV1NotSupportedError 4 ctx1adbc

15from pydantic import BaseModel, Field, ValidationError 4 ctx1adbc

16 

17 

18class Person: 4 ctx1adbc

19 def __init__(self, name: str): 4 ctx1adbc

20 self.name = name 7 ctx1oepqfrg

21 

22 

23class Pet: 4 ctx1adbc

24 def __init__(self, owner: Person, name: str): 4 ctx1adbc

25 self.owner = owner 7 ctx1oepqfrg

26 self.name = name 7 ctx1oepqfrg

27 

28 

29@dataclass 4 ctx1adbc

30class Item: 4 ctx1adbc

31 name: str 3 ctx1abc

32 count: int 3 ctx1abc

33 

34 

35class DictablePerson(Person): 4 ctx1adbc

36 def __iter__(self): 4 ctx1adbc

37 return ((k, v) for k, v in self.__dict__.items()) 4 ctx1etfg

38 

39 

40class DictablePet(Pet): 4 ctx1adbc

41 def __iter__(self): 4 ctx1adbc

42 return ((k, v) for k, v in self.__dict__.items()) 4 ctx1etfg

43 

44 

45class Unserializable: 4 ctx1adbc

46 def __iter__(self): 4 ctx1adbc

47 raise NotImplementedError() 4 ctx1VWXY

48 

49 @property 4 ctx1adbc

50 def __dict__(self): 4 ctx1adbc

51 raise NotImplementedError() 4 ctx1VWXY

52 

53 

54class RoleEnum(Enum): 4 ctx1adbc

55 admin = "admin" 4 ctx1adbc

56 normal = "normal" 4 ctx1adbc

57 

58 

59class ModelWithConfig(BaseModel): 4 ctx1adbc

60 role: RoleEnum | None = None 4 ctx1adbc

61 

62 model_config = {"use_enum_values": True} 4 ctx1adbc

63 

64 

65class ModelWithAlias(BaseModel): 4 ctx1adbc

66 foo: str = Field(alias="Foo") 4 ctx1adbc

67 

68 

69class ModelWithDefault(BaseModel): 4 ctx1adbc

70 foo: str = ... # type: ignore 4 ctx1adbc

71 bar: str = "bar" 4 ctx1adbc

72 bla: str = "bla" 4 ctx1adbc

73 

74 

75def test_encode_dict(): 4 ctx1adbc

76 pet = {"name": "Firulais", "owner": {"name": "Foo"}} 4 ctx1GHIJ

77 assert jsonable_encoder(pet) == {"name": "Firulais", "owner": {"name": "Foo"}} 4 ctx1GHIJ

78 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 4 ctx1GHIJ

79 assert jsonable_encoder(pet, exclude={"owner"}) == {"name": "Firulais"} 4 ctx1GHIJ

80 assert jsonable_encoder(pet, include={}) == {} 4 ctx1GHIJ

81 assert jsonable_encoder(pet, exclude={}) == { 4 ctx1GHIJ

82 "name": "Firulais", 

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

84 } 

85 

86 

87def test_encode_dict_include_exclude_list(): 4 ctx1adbc

88 pet = {"name": "Firulais", "owner": {"name": "Foo"}} 4 ctx1KLMN

89 assert jsonable_encoder(pet) == {"name": "Firulais", "owner": {"name": "Foo"}} 4 ctx1KLMN

90 assert jsonable_encoder(pet, include=["name"]) == {"name": "Firulais"} 4 ctx1KLMN

91 assert jsonable_encoder(pet, exclude=["owner"]) == {"name": "Firulais"} 4 ctx1KLMN

92 assert jsonable_encoder(pet, include=[]) == {} 4 ctx1KLMN

93 assert jsonable_encoder(pet, exclude=[]) == { 4 ctx1KLMN

94 "name": "Firulais", 

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

96 } 

97 

98 

99def test_encode_class(): 4 ctx1adbc

100 person = Person(name="Foo") 4 ctx1opqr

101 pet = Pet(owner=person, name="Firulais") 4 ctx1opqr

102 assert jsonable_encoder(pet) == {"name": "Firulais", "owner": {"name": "Foo"}} 4 ctx1opqr

103 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 4 ctx1opqr

104 assert jsonable_encoder(pet, exclude={"owner"}) == {"name": "Firulais"} 4 ctx1opqr

105 assert jsonable_encoder(pet, include={}) == {} 4 ctx1opqr

106 assert jsonable_encoder(pet, exclude={}) == { 4 ctx1opqr

107 "name": "Firulais", 

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

109 } 

110 

111 

112def test_encode_dictable(): 4 ctx1adbc

113 person = DictablePerson(name="Foo") 4 ctx1etfg

114 pet = DictablePet(owner=person, name="Firulais") 4 ctx1etfg

115 assert jsonable_encoder(pet) == {"name": "Firulais", "owner": {"name": "Foo"}} 4 ctx1etfg

116 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 4 ctx1etfg

117 assert jsonable_encoder(pet, exclude={"owner"}) == {"name": "Firulais"} 4 ctx1etfg

118 assert jsonable_encoder(pet, include={}) == {} 4 ctx1etfg

119 assert jsonable_encoder(pet, exclude={}) == { 4 ctx1etfg

120 "name": "Firulais", 

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

122 } 

123 

124 

125def test_encode_dataclass(): 4 ctx1adbc

126 item = Item(name="foo", count=100) 4 ctx1OPQR

127 assert jsonable_encoder(item) == {"name": "foo", "count": 100} 4 ctx1OPQR

128 assert jsonable_encoder(item, include={"name"}) == {"name": "foo"} 4 ctx1OPQR

129 assert jsonable_encoder(item, exclude={"count"}) == {"name": "foo"} 4 ctx1OPQR

130 assert jsonable_encoder(item, include={}) == {} 4 ctx1OPQR

131 assert jsonable_encoder(item, exclude={}) == {"name": "foo", "count": 100} 4 ctx1OPQR

132 

133 

134def test_encode_unsupported(): 4 ctx1adbc

135 unserializable = Unserializable() 4 ctx1VWXY

136 with pytest.raises(ValueError): 4 ctx1VWXY

137 jsonable_encoder(unserializable) 4 ctx1VWXY

138 

139 

140def test_encode_custom_json_encoders_model_pydanticv2(): 4 ctx1adbc

141 from pydantic import field_serializer 4 ctx1hkij

142 

143 class ModelWithCustomEncoder(BaseModel): 4 ctx1hkij

144 dt_field: datetime 3 ctx1hij

145 

146 @field_serializer("dt_field") 4 ctx1hkij

147 def serialize_dt_field(self, dt): 4 ctx1hkij

148 return dt.replace(microsecond=0, tzinfo=timezone.utc).isoformat() 4 ctx1hkij

149 

150 class ModelWithCustomEncoderSubclass(ModelWithCustomEncoder): 4 ctx1hkij

151 pass 4 ctx1hkij

152 

153 model = ModelWithCustomEncoder(dt_field=datetime(2019, 1, 1, 8)) 4 ctx1hkij

154 assert jsonable_encoder(model) == {"dt_field": "2019-01-01T08:00:00+00:00"} 4 ctx1hkij

155 subclass_model = ModelWithCustomEncoderSubclass(dt_field=datetime(2019, 1, 1, 8)) 4 ctx1hkij

156 assert jsonable_encoder(subclass_model) == {"dt_field": "2019-01-01T08:00:00+00:00"} 4 ctx1hkij

157 

158 

159def test_json_encoder_error_with_pydanticv1(): 4 ctx1adbc

160 with warnings.catch_warnings(): 4 ctx1yBzA

161 warnings.simplefilter("ignore", UserWarning) 4 ctx1yBzA

162 from pydantic import v1 4 ctx1yBzA

163 

164 class ModelV1(v1.BaseModel): 4 ctx1yBzA

165 name: str 3 ctx1yzA

166 

167 data = ModelV1(name="test") 4 ctx1yBzA

168 with pytest.raises(PydanticV1NotSupportedError): 4 ctx1yBzA

169 jsonable_encoder(data) 4 ctx1yBzA

170 

171 

172def test_encode_model_with_config(): 4 ctx1adbc

173 model = ModelWithConfig(role=RoleEnum.admin) 4 ctx1)*+,

174 assert jsonable_encoder(model) == {"role": "admin"} 4 ctx1)*+,

175 

176 

177def test_encode_model_with_alias_raises(): 4 ctx1adbc

178 with pytest.raises(ValidationError): 4 ctx1-./:

179 ModelWithAlias(foo="Bar") 4 ctx1-./:

180 

181 

182def test_encode_model_with_alias(): 4 ctx1adbc

183 model = ModelWithAlias(Foo="Bar") 4 ctx1;=?@

184 assert jsonable_encoder(model) == {"Foo": "Bar"} 4 ctx1;=?@

185 

186 

187def test_encode_model_with_default(): 4 ctx1adbc

188 model = ModelWithDefault(foo="foo", bar="bar") 4 ctx1uvwx

189 assert jsonable_encoder(model) == {"foo": "foo", "bar": "bar", "bla": "bla"} 4 ctx1uvwx

190 assert jsonable_encoder(model, exclude_unset=True) == {"foo": "foo", "bar": "bar"} 4 ctx1uvwx

191 assert jsonable_encoder(model, exclude_defaults=True) == {"foo": "foo"} 4 ctx1uvwx

192 assert jsonable_encoder(model, exclude_unset=True, exclude_defaults=True) == { 4 ctx1uvwx

193 "foo": "foo" 

194 } 

195 assert jsonable_encoder(model, include={"foo"}) == {"foo": "foo"} 4 ctx1uvwx

196 assert jsonable_encoder(model, exclude={"bla"}) == {"foo": "foo", "bar": "bar"} 4 ctx1uvwx

197 assert jsonable_encoder(model, include={}) == {} 4 ctx1uvwx

198 assert jsonable_encoder(model, exclude={}) == { 4 ctx1uvwx

199 "foo": "foo", 

200 "bar": "bar", 

201 "bla": "bla", 

202 } 

203 

204 

205def test_custom_encoders(): 4 ctx1adbc

206 class safe_datetime(datetime): 4 ctx1lsmn

207 pass 4 ctx1lsmn

208 

209 class MyDict(TypedDict): 4 ctx1lsmn

210 dt_field: safe_datetime 3 ctx1lmn

211 

212 instance = MyDict(dt_field=safe_datetime.now()) 4 ctx1lsmn

213 

214 encoded_instance = jsonable_encoder( 4 ctx1lsmn

215 instance, custom_encoder={safe_datetime: lambda o: o.strftime("%H:%M:%S")} 

216 ) 

217 assert encoded_instance["dt_field"] == instance["dt_field"].strftime("%H:%M:%S") 4 ctx1lsmn

218 

219 encoded_instance = jsonable_encoder( 4 ctx1lsmn

220 instance, custom_encoder={datetime: lambda o: o.strftime("%H:%M:%S")} 

221 ) 

222 assert encoded_instance["dt_field"] == instance["dt_field"].strftime("%H:%M:%S") 4 ctx1lsmn

223 

224 encoded_instance2 = jsonable_encoder(instance) 4 ctx1lsmn

225 assert encoded_instance2["dt_field"] == instance["dt_field"].isoformat() 4 ctx1lsmn

226 

227 

228def test_custom_enum_encoders(): 4 ctx1adbc

229 def custom_enum_encoder(v: Enum): 4 ctx1CDEF

230 return v.value.lower() 4 ctx1CDEF

231 

232 class MyEnum(Enum): 4 ctx1CDEF

233 ENUM_VAL_1 = "ENUM_VAL_1" 4 ctx1CDEF

234 

235 instance = MyEnum.ENUM_VAL_1 4 ctx1CDEF

236 

237 encoded_instance = jsonable_encoder( 4 ctx1CDEF

238 instance, custom_encoder={MyEnum: custom_enum_encoder} 

239 ) 

240 assert encoded_instance == custom_enum_encoder(instance) 4 ctx1CDEF

241 

242 

243def test_encode_model_with_pure_path(): 4 ctx1adbc

244 class ModelWithPath(BaseModel): 4 ctx1SZTU

245 path: PurePath 3 ctx1STU

246 

247 model_config = {"arbitrary_types_allowed": True} 4 ctx1SZTU

248 

249 test_path = PurePath("/foo", "bar") 4 ctx1SZTU

250 obj = ModelWithPath(path=test_path) 4 ctx1SZTU

251 assert jsonable_encoder(obj) == {"path": str(test_path)} 4 ctx1SZTU

252 

253 

254def test_encode_model_with_pure_posix_path(): 4 ctx1adbc

255 class ModelWithPath(BaseModel): 4 ctx10612

256 path: PurePosixPath 3 ctx1012

257 

258 model_config = {"arbitrary_types_allowed": True} 4 ctx10612

259 

260 obj = ModelWithPath(path=PurePosixPath("/foo", "bar")) 4 ctx10612

261 assert jsonable_encoder(obj) == {"path": "/foo/bar"} 4 ctx10612

262 

263 

264def test_encode_model_with_pure_windows_path(): 4 ctx1adbc

265 class ModelWithPath(BaseModel): 4 ctx13745

266 path: PureWindowsPath 3 ctx1345

267 

268 model_config = {"arbitrary_types_allowed": True} 4 ctx13745

269 

270 obj = ModelWithPath(path=PureWindowsPath("/foo", "bar")) 4 ctx13745

271 assert jsonable_encoder(obj) == {"path": "\\foo\\bar"} 4 ctx13745

272 

273 

274def test_encode_pure_path(): 4 ctx1adbc

275 test_path = PurePath("/foo", "bar") 4 ctx1[]^_

276 

277 assert jsonable_encoder({"path": test_path}) == {"path": str(test_path)} 4 ctx1[]^_

278 

279 

280def test_decimal_encoder_float(): 4 ctx1adbc

281 data = {"value": Decimal(1.23)} 4 ctx1`{|}

282 assert jsonable_encoder(data) == {"value": 1.23} 4 ctx1`{|}

283 

284 

285def test_decimal_encoder_int(): 4 ctx1adbc

286 data = {"value": Decimal(2)} 4 ctx2~ abbbcb

287 assert jsonable_encoder(data) == {"value": 2} 4 ctx2~ abbbcb

288 

289 

290def test_decimal_encoder_nan(): 4 ctx1adbc

291 data = {"value": Decimal("NaN")} 4 ctx2dbebfbgb

292 assert isnan(jsonable_encoder(data)["value"]) 4 ctx2dbebfbgb

293 

294 

295def test_decimal_encoder_infinity(): 4 ctx1adbc

296 data = {"value": Decimal("Infinity")} 4 ctx189!#

297 assert isinf(jsonable_encoder(data)["value"]) 4 ctx189!#

298 data = {"value": Decimal("-Infinity")} 4 ctx189!#

299 assert isinf(jsonable_encoder(data)["value"]) 4 ctx189!#

300 

301 

302def test_encode_deque_encodes_child_models(): 4 ctx1adbc

303 class Model(BaseModel): 4 ctx1$(%'

304 test: str 3 ctx1$%'

305 

306 dq = deque([Model(test="test")]) 4 ctx1$(%'

307 

308 assert jsonable_encoder(dq)[0]["test"] == "test" 4 ctx1$(%'

309 

310 

311def test_encode_pydantic_undefined(): 4 ctx1adbc

312 data = {"value": Undefined} 4 ctx2hbibjbkb

313 assert jsonable_encoder(data) == {"value": None} 4 ctx2hbibjbkb