Coverage for tests/test_compat.py: 100%

1from typing import Any, Dict, List, Union 7 ctx1abcdefg

2 

3from fastapi import FastAPI, UploadFile 7 ctx1abcdefg

4from fastapi._compat import ( 7 ctx1abcdefg

5 Undefined, 

6 _get_model_config, 

7 get_cached_model_fields, 

8 is_scalar_field, 

9 is_uploadfile_sequence_annotation, 

10 may_v1, 

11) 

12from fastapi._compat.shared import is_bytes_sequence_annotation 7 ctx1abcdefg

13from fastapi.testclient import TestClient 7 ctx1abcdefg

14from pydantic import BaseModel, ConfigDict 7 ctx1abcdefg

15from pydantic.fields import FieldInfo 7 ctx1abcdefg

16 

17from .utils import needs_py310, needs_py_lt_314, needs_pydanticv2 7 ctx1abcdefg

18 

19 

20@needs_pydanticv2 7 ctx1abcdefg

21def test_model_field_default_required(): 7 ctx1abcdefg

22 from fastapi._compat import v2 7 ctx156789!#

23 

24 # For coverage 

25 field_info = FieldInfo(annotation=str) 7 ctx156789!#

26 field = v2.ModelField(name="foo", field_info=field_info) 7 ctx156789!#

27 assert field.default is Undefined 7 ctx156789!#

28 

29 

30@needs_py_lt_314 7 ctx1abcdefg

31def test_v1_plain_validator_function(): 7 ctx1abcdefg

32 from fastapi._compat import v1 5 ctx1$%'()

33 

34 # For coverage 

35 def func(v): # pragma: no cover 5 ctx1$%'()

36 return v 

37 

38 result = v1.with_info_plain_validator_function(func) 5 ctx1$%'()

39 assert result == {} 5 ctx1$%'()

40 

41 

42def test_is_model_field(): 7 ctx1abcdefg

43 # For coverage 

44 from fastapi._compat import _is_model_field 7 ctx1*+,-./:

45 

46 assert not _is_model_field(str) 7 ctx1*+,-./:

47 

48 

49@needs_pydanticv2 7 ctx1abcdefg

50def test_get_model_config(): 7 ctx1abcdefg

51 # For coverage in Pydantic v2 

52 class Foo(BaseModel): 7 ctx1TUVWXYZ

53 model_config = ConfigDict(from_attributes=True) 7 ctx1TUVWXYZ

54 

55 foo = Foo() 7 ctx1TUVWXYZ

56 config = _get_model_config(foo) 7 ctx1TUVWXYZ

57 assert config == {"from_attributes": True} 7 ctx1TUVWXYZ

58 

59 

60def test_complex(): 7 ctx1abcdefg

61 app = FastAPI() 7 ctx1opqrstu

62 

63 @app.post("/") 7 ctx1opqrstu

64 def foo(foo: Union[str, List[int]]): 7 ctx1opqrstu

65 return foo 7 ctx1opqrstu

66 

67 client = TestClient(app) 7 ctx1opqrstu

68 

69 response = client.post("/", json="bar") 7 ctx1opqrstu

70 assert response.status_code == 200, response.text 7 ctx1opqrstu

71 assert response.json() == "bar" 7 ctx1opqrstu

72 

73 response2 = client.post("/", json=[1, 2]) 7 ctx1opqrstu

74 assert response2.status_code == 200, response2.text 7 ctx1opqrstu

75 assert response2.json() == [1, 2] 7 ctx1opqrstu

76 

77 

78@needs_pydanticv2 7 ctx1abcdefg

79def test_propagates_pydantic2_model_config(): 7 ctx1abcdefg

80 app = FastAPI() 7 ctx1hijklmn

81 

82 class Missing: 7 ctx1hijklmn

83 def __bool__(self): 7 ctx1hijklmn

84 return False 7 ctx1hijklmn

85 

86 class EmbeddedModel(BaseModel): 7 ctx1hijklmn

87 model_config = ConfigDict(arbitrary_types_allowed=True) 7 ctx1hijklmn

88 value: Union[str, Missing] = Missing() 7 ctx1hijklmn

89 

90 class Model(BaseModel): 7 ctx1hijklmn

91 model_config = ConfigDict( 7 ctx1hijklmn

92 arbitrary_types_allowed=True, 

93 ) 

94 value: Union[str, Missing] = Missing() 7 ctx1hijklmn

95 embedded_model: EmbeddedModel = EmbeddedModel() 7 ctx1hijklmn

96 

97 @app.post("/") 7 ctx1hijklmn

98 def foo(req: Model) -> Dict[str, Union[str, None]]: 7 ctx1hijklmn

99 return { 7 ctx1hijklmn

100 "value": req.value or None, 

101 "embedded_value": req.embedded_model.value or None, 

102 } 

103 

104 client = TestClient(app) 7 ctx1hijklmn

105 

106 response = client.post("/", json={}) 7 ctx1hijklmn

107 assert response.status_code == 200, response.text 7 ctx1hijklmn

108 assert response.json() == { 7 ctx1hijklmn

109 "value": None, 

110 "embedded_value": None, 

111 } 

112 

113 response2 = client.post( 7 ctx1hijklmn

114 "/", json={"value": "foo", "embedded_model": {"value": "bar"}} 

115 ) 

116 assert response2.status_code == 200, response2.text 7 ctx1hijklmn

117 assert response2.json() == { 7 ctx1hijklmn

118 "value": "foo", 

119 "embedded_value": "bar", 

120 } 

121 

122 

123def test_is_bytes_sequence_annotation_union(): 7 ctx1abcdefg

124 # For coverage 

125 # TODO: in theory this would allow declaring types that could be lists of bytes 

126 # to be read from files and other types, but I'm not even sure it's a good idea 

127 # to support it as a first class "feature" 

128 assert is_bytes_sequence_annotation(Union[List[str], List[bytes]]) 7 ctx1;=?@[]^

129 

130 

131def test_is_uploadfile_sequence_annotation(): 7 ctx1abcdefg

132 # For coverage 

133 # TODO: in theory this would allow declaring types that could be lists of UploadFile 

134 # and other types, but I'm not even sure it's a good idea to support it as a first 

135 # class "feature" 

136 assert is_uploadfile_sequence_annotation(Union[List[str], List[UploadFile]]) 7 ctx2_ ` { | } ~ ab

137 

138 

139@needs_pydanticv2 7 ctx1abcdefg

140def test_serialize_sequence_value_with_optional_list(): 7 ctx1abcdefg

141 """Test that serialize_sequence_value handles optional lists correctly.""" 

142 from fastapi._compat import v2 7 ctx1ABCDEFG

143 

144 field_info = FieldInfo(annotation=Union[List[str], None]) 7 ctx1ABCDEFG

145 field = v2.ModelField(name="items", field_info=field_info) 7 ctx1ABCDEFG

146 result = v2.serialize_sequence_value(field=field, value=["a", "b", "c"]) 7 ctx1ABCDEFG

147 assert result == ["a", "b", "c"] 7 ctx1ABCDEFG

148 assert isinstance(result, list) 7 ctx1ABCDEFG

149 

150 

151@needs_pydanticv2 7 ctx1abcdefg

152@needs_py310 7 ctx1abcdefg

153def test_serialize_sequence_value_with_optional_list_pipe_union(): 7 ctx1abcdefg

154 """Test that serialize_sequence_value handles optional lists correctly (with new syntax).""" 

155 from fastapi._compat import v2 5 ctx1HIJKL

156 

157 field_info = FieldInfo(annotation=list[str] | None) 5 ctx1HIJKL

158 field = v2.ModelField(name="items", field_info=field_info) 5 ctx1HIJKL

159 result = v2.serialize_sequence_value(field=field, value=["a", "b", "c"]) 5 ctx1HIJKL

160 assert result == ["a", "b", "c"] 5 ctx1HIJKL

161 assert isinstance(result, list) 5 ctx1HIJKL

162 

163 

164@needs_pydanticv2 7 ctx1abcdefg

165def test_serialize_sequence_value_with_none_first_in_union(): 7 ctx1abcdefg

166 """Test that serialize_sequence_value handles Union[None, List[...]] correctly.""" 

167 from fastapi._compat import v2 7 ctx1MNOPQRS

168 

169 field_info = FieldInfo(annotation=Union[None, List[str]]) 7 ctx1MNOPQRS

170 field = v2.ModelField(name="items", field_info=field_info) 7 ctx1MNOPQRS

171 result = v2.serialize_sequence_value(field=field, value=["x", "y"]) 7 ctx1MNOPQRS

172 assert result == ["x", "y"] 7 ctx1MNOPQRS

173 assert isinstance(result, list) 7 ctx1MNOPQRS

174 

175 

176@needs_py_lt_314 7 ctx1abcdefg

177def test_is_pv1_scalar_field(): 7 ctx1abcdefg

178 from fastapi._compat import v1 5 ctx101234

179 

180 # For coverage 

181 class Model(v1.BaseModel): 5 ctx101234

182 foo: Union[str, Dict[str, Any]] 5 ctx101234

183 

184 fields = v1.get_model_fields(Model) 5 ctx101234

185 assert not is_scalar_field(fields[0]) 5 ctx101234

186 

187 

188@needs_py_lt_314 7 ctx1abcdefg

189def test_get_model_fields_cached(): 7 ctx1abcdefg

190 from fastapi._compat import v1 5 ctx1vwxyz

191 

192 class Model(may_v1.BaseModel): 5 ctx1vwxyz

193 foo: str 5 ctx1vwxyz

194 

195 non_cached_fields = v1.get_model_fields(Model) 5 ctx1vwxyz

196 non_cached_fields2 = v1.get_model_fields(Model) 5 ctx1vwxyz

197 cached_fields = get_cached_model_fields(Model) 5 ctx1vwxyz

198 cached_fields2 = get_cached_model_fields(Model) 5 ctx1vwxyz

199 for f1, f2 in zip(cached_fields, cached_fields2): 5 ctx1vwxyz

200 assert f1 is f2 5 ctx1vwxyz

201 

202 assert non_cached_fields is not non_cached_fields2 5 ctx1vwxyz

203 assert cached_fields is cached_fields2 5 ctx1vwxyz