Coverage for tests / test_jsonable_encoder.py: 100%

1import warnings 4 ctx1abcd

2from collections import deque 4 ctx1abcd

3from dataclasses import dataclass 4 ctx1abcd

4from datetime import datetime, timezone 4 ctx1abcd

5from decimal import Decimal 4 ctx1abcd

6from enum import Enum 4 ctx1abcd

7from math import isinf, isnan 4 ctx1abcd

8from pathlib import PurePath, PurePosixPath, PureWindowsPath 4 ctx1abcd

9from typing import Optional, TypedDict 4 ctx1abcd

10 

11import pytest 4 ctx1abcd

12from fastapi._compat import Undefined 4 ctx1abcd

13from fastapi.encoders import jsonable_encoder 4 ctx1abcd

14from fastapi.exceptions import PydanticV1NotSupportedError 4 ctx1abcd

15from pydantic import BaseModel, Field, ValidationError 4 ctx1abcd

16 

17 

18class Person: 4 ctx1abcd

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

20 self.name = name 6 ctx1neofpg

21 

22 

23class Pet: 4 ctx1abcd

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

25 self.owner = owner 6 ctx1neofpg

26 self.name = name 6 ctx1neofpg

27 

28 

29@dataclass 4 ctx1abcd

30class Item: 4 ctx1abcd

31 name: str 4 ctx1abcd

32 count: int 4 ctx1abcd

33 

34 

35class DictablePerson(Person): 4 ctx1abcd

36 def __iter__(self): 4 ctx1abcd

37 return ((k, v) for k, v in self.__dict__.items()) 3 ctx1efg

38 

39 

40class DictablePet(Pet): 4 ctx1abcd

41 def __iter__(self): 4 ctx1abcd

42 return ((k, v) for k, v in self.__dict__.items()) 3 ctx1efg

43 

44 

45class Unserializable: 4 ctx1abcd

46 def __iter__(self): 4 ctx1abcd

47 raise NotImplementedError() 3 ctx1LMN

48 

49 @property 4 ctx1abcd

50 def __dict__(self): 4 ctx1abcd

51 raise NotImplementedError() 3 ctx1LMN

52 

53 

54class RoleEnum(Enum): 4 ctx1abcd

55 admin = "admin" 4 ctx1abcd

56 normal = "normal" 4 ctx1abcd

57 

58 

59class ModelWithConfig(BaseModel): 4 ctx1abcd

60 role: Optional[RoleEnum] = None 4 ctx1abcd

61 

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

63 

64 

65class ModelWithAlias(BaseModel): 4 ctx1abcd

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

67 

68 

69class ModelWithDefault(BaseModel): 4 ctx1abcd

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

71 bar: str = "bar" 4 ctx1abcd

72 bla: str = "bla" 4 ctx1abcd

73 

74 

75def test_encode_dict(): 4 ctx1abcd

76 pet = {"name": "Firulais", "owner": {"name": "Foo"}} 3 ctx1zAB

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

78 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 3 ctx1zAB

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

80 assert jsonable_encoder(pet, include={}) == {} 3 ctx1zAB

81 assert jsonable_encoder(pet, exclude={}) == { 3 ctx1zAB

82 "name": "Firulais", 

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

84 } 

85 

86 

87def test_encode_dict_include_exclude_list(): 4 ctx1abcd

88 pet = {"name": "Firulais", "owner": {"name": "Foo"}} 3 ctx1CDE

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

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

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

92 assert jsonable_encoder(pet, include=[]) == {} 3 ctx1CDE

93 assert jsonable_encoder(pet, exclude=[]) == { 3 ctx1CDE

94 "name": "Firulais", 

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

96 } 

97 

98 

99def test_encode_class(): 4 ctx1abcd

100 person = Person(name="Foo") 3 ctx1nop

101 pet = Pet(owner=person, name="Firulais") 3 ctx1nop

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

103 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 3 ctx1nop

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

105 assert jsonable_encoder(pet, include={}) == {} 3 ctx1nop

106 assert jsonable_encoder(pet, exclude={}) == { 3 ctx1nop

107 "name": "Firulais", 

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

109 } 

110 

111 

112def test_encode_dictable(): 4 ctx1abcd

113 person = DictablePerson(name="Foo") 3 ctx1efg

114 pet = DictablePet(owner=person, name="Firulais") 3 ctx1efg

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

116 assert jsonable_encoder(pet, include={"name"}) == {"name": "Firulais"} 3 ctx1efg

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

118 assert jsonable_encoder(pet, include={}) == {} 3 ctx1efg

119 assert jsonable_encoder(pet, exclude={}) == { 3 ctx1efg

120 "name": "Firulais", 

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

122 } 

123 

124 

125def test_encode_dataclass(): 4 ctx1abcd

126 item = Item(name="foo", count=100) 3 ctx1FGH

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

128 assert jsonable_encoder(item, include={"name"}) == {"name": "foo"} 3 ctx1FGH

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

130 assert jsonable_encoder(item, include={}) == {} 3 ctx1FGH

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

132 

133 

134def test_encode_unsupported(): 4 ctx1abcd

135 unserializable = Unserializable() 3 ctx1LMN

136 with pytest.raises(ValueError): 3 ctx1LMN

137 jsonable_encoder(unserializable) 3 ctx1LMN

138 

139 

140def test_encode_custom_json_encoders_model_pydanticv2(): 4 ctx1abcd

141 from pydantic import field_serializer 3 ctx1hij

142 

143 class ModelWithCustomEncoder(BaseModel): 3 ctx1hij

144 dt_field: datetime 3 ctx1hij

145 

146 @field_serializer("dt_field") 3 ctx1hij

147 def serialize_dt_field(self, dt): 3 ctx1hij

148 return dt.replace(microsecond=0, tzinfo=timezone.utc).isoformat() 3 ctx1hij

149 

150 class ModelWithCustomEncoderSubclass(ModelWithCustomEncoder): 3 ctx1hij

151 pass 3 ctx1hij

152 

153 model = ModelWithCustomEncoder(dt_field=datetime(2019, 1, 1, 8)) 3 ctx1hij

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

155 subclass_model = ModelWithCustomEncoderSubclass(dt_field=datetime(2019, 1, 1, 8)) 3 ctx1hij

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

157 

158 

159def test_json_encoder_error_with_pydanticv1(): 4 ctx1abcd

160 with warnings.catch_warnings(): 3 ctx1tvu

161 warnings.simplefilter("ignore", UserWarning) 3 ctx1tvu

162 from pydantic import v1 3 ctx1tvu

163 

164 class ModelV1(v1.BaseModel): 3 ctx1tvu

165 name: str 2 ctx1tu

166 

167 data = ModelV1(name="test") 3 ctx1tvu

168 with pytest.raises(PydanticV1NotSupportedError): 3 ctx1tvu

169 jsonable_encoder(data) 3 ctx1tvu

170 

171 

172def test_encode_model_with_config(): 4 ctx1abcd

173 model = ModelWithConfig(role=RoleEnum.admin) 3 ctx1012

174 assert jsonable_encoder(model) == {"role": "admin"} 3 ctx1012

175 

176 

177def test_encode_model_with_alias_raises(): 4 ctx1abcd

178 with pytest.raises(ValidationError): 3 ctx1345

179 ModelWithAlias(foo="Bar") 3 ctx1345

180 

181 

182def test_encode_model_with_alias(): 4 ctx1abcd

183 model = ModelWithAlias(Foo="Bar") 3 ctx1678

184 assert jsonable_encoder(model) == {"Foo": "Bar"} 3 ctx1678

185 

186 

187def test_encode_model_with_default(): 4 ctx1abcd

188 model = ModelWithDefault(foo="foo", bar="bar") 3 ctx1qrs

189 assert jsonable_encoder(model) == {"foo": "foo", "bar": "bar", "bla": "bla"} 3 ctx1qrs

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

191 assert jsonable_encoder(model, exclude_defaults=True) == {"foo": "foo"} 3 ctx1qrs

192 assert jsonable_encoder(model, exclude_unset=True, exclude_defaults=True) == { 3 ctx1qrs

193 "foo": "foo" 

194 } 

195 assert jsonable_encoder(model, include={"foo"}) == {"foo": "foo"} 3 ctx1qrs

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

197 assert jsonable_encoder(model, include={}) == {} 3 ctx1qrs

198 assert jsonable_encoder(model, exclude={}) == { 3 ctx1qrs

199 "foo": "foo", 

200 "bar": "bar", 

201 "bla": "bla", 

202 } 

203 

204 

205def test_custom_encoders(): 4 ctx1abcd

206 class safe_datetime(datetime): 3 ctx1klm

207 pass 3 ctx1klm

208 

209 class MyDict(TypedDict): 3 ctx1klm

210 dt_field: safe_datetime 3 ctx1klm

211 

212 instance = MyDict(dt_field=safe_datetime.now()) 3 ctx1klm

213 

214 encoded_instance = jsonable_encoder( 3 ctx1klm

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") 3 ctx1klm

218 

219 encoded_instance = jsonable_encoder( 3 ctx1klm

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") 3 ctx1klm

223 

224 encoded_instance2 = jsonable_encoder(instance) 3 ctx1klm

225 assert encoded_instance2["dt_field"] == instance["dt_field"].isoformat() 3 ctx1klm

226 

227 

228def test_custom_enum_encoders(): 4 ctx1abcd

229 def custom_enum_encoder(v: Enum): 3 ctx1wxy

230 return v.value.lower() 3 ctx1wxy

231 

232 class MyEnum(Enum): 3 ctx1wxy

233 ENUM_VAL_1 = "ENUM_VAL_1" 3 ctx1wxy

234 

235 instance = MyEnum.ENUM_VAL_1 3 ctx1wxy

236 

237 encoded_instance = jsonable_encoder( 3 ctx1wxy

238 instance, custom_encoder={MyEnum: custom_enum_encoder} 

239 ) 

240 assert encoded_instance == custom_enum_encoder(instance) 3 ctx1wxy

241 

242 

243def test_encode_model_with_pure_path(): 4 ctx1abcd

244 class ModelWithPath(BaseModel): 3 ctx1IJK

245 path: PurePath 3 ctx1IJK

246 

247 model_config = {"arbitrary_types_allowed": True} 3 ctx1IJK

248 

249 test_path = PurePath("/foo", "bar") 3 ctx1IJK

250 obj = ModelWithPath(path=test_path) 3 ctx1IJK

251 assert jsonable_encoder(obj) == {"path": str(test_path)} 3 ctx1IJK

252 

253 

254def test_encode_model_with_pure_posix_path(): 4 ctx1abcd

255 class ModelWithPath(BaseModel): 3 ctx1OPQ

256 path: PurePosixPath 3 ctx1OPQ

257 

258 model_config = {"arbitrary_types_allowed": True} 3 ctx1OPQ

259 

260 obj = ModelWithPath(path=PurePosixPath("/foo", "bar")) 3 ctx1OPQ

261 assert jsonable_encoder(obj) == {"path": "/foo/bar"} 3 ctx1OPQ

262 

263 

264def test_encode_model_with_pure_windows_path(): 4 ctx1abcd

265 class ModelWithPath(BaseModel): 3 ctx1RST

266 path: PureWindowsPath 3 ctx1RST

267 

268 model_config = {"arbitrary_types_allowed": True} 3 ctx1RST

269 

270 obj = ModelWithPath(path=PureWindowsPath("/foo", "bar")) 3 ctx1RST

271 assert jsonable_encoder(obj) == {"path": "\\foo\\bar"} 3 ctx1RST

272 

273 

274def test_encode_pure_path(): 4 ctx1abcd

275 test_path = PurePath("/foo", "bar") 3 ctx19!#

276 

277 assert jsonable_encoder({"path": test_path}) == {"path": str(test_path)} 3 ctx19!#

278 

279 

280def test_decimal_encoder_float(): 4 ctx1abcd

281 data = {"value": Decimal(1.23)} 3 ctx1$%'

282 assert jsonable_encoder(data) == {"value": 1.23} 3 ctx1$%'

283 

284 

285def test_decimal_encoder_int(): 4 ctx1abcd

286 data = {"value": Decimal(2)} 3 ctx1()*

287 assert jsonable_encoder(data) == {"value": 2} 3 ctx1()*

288 

289 

290def test_decimal_encoder_nan(): 4 ctx1abcd

291 data = {"value": Decimal("NaN")} 3 ctx1+,-

292 assert isnan(jsonable_encoder(data)["value"]) 3 ctx1+,-

293 

294 

295def test_decimal_encoder_infinity(): 4 ctx1abcd

296 data = {"value": Decimal("Infinity")} 3 ctx1UVW

297 assert isinf(jsonable_encoder(data)["value"]) 3 ctx1UVW

298 data = {"value": Decimal("-Infinity")} 3 ctx1UVW

299 assert isinf(jsonable_encoder(data)["value"]) 3 ctx1UVW

300 

301 

302def test_encode_deque_encodes_child_models(): 4 ctx1abcd

303 class Model(BaseModel): 3 ctx1XYZ

304 test: str 3 ctx1XYZ

305 

306 dq = deque([Model(test="test")]) 3 ctx1XYZ

307 

308 assert jsonable_encoder(dq)[0]["test"] == "test" 3 ctx1XYZ

309 

310 

311def test_encode_pydantic_undefined(): 4 ctx1abcd

312 data = {"value": Undefined} 3 ctx1./:

313 assert jsonable_encoder(data) == {"value": None} 3 ctx1./: