Coverage for tests / test_compat.py: 100%

1from typing import Union 4 ctx1defg

2 

3from fastapi import FastAPI, UploadFile 4 ctx1defg

4from fastapi._compat import ( 4 ctx1defg

5 Undefined, 

6 is_uploadfile_sequence_annotation, 

7) 

8from fastapi._compat.shared import is_bytes_sequence_annotation 4 ctx1defg

9from fastapi.testclient import TestClient 4 ctx1defg

10from pydantic import BaseModel, ConfigDict 4 ctx1defg

11from pydantic.fields import FieldInfo 4 ctx1defg

12 

13from .utils import needs_py310 4 ctx1defg

14 

15 

16def test_model_field_default_required(): 4 ctx1defg

17 from fastapi._compat import v2 3 ctx1tuv

18 

19 # For coverage 

20 field_info = FieldInfo(annotation=str) 3 ctx1tuv

21 field = v2.ModelField(name="foo", field_info=field_info) 3 ctx1tuv

22 assert field.default is Undefined 3 ctx1tuv

23 

24 

25def test_complex(): 4 ctx1defg

26 app = FastAPI() 3 ctx1hij

27 

28 @app.post("/") 3 ctx1hij

29 def foo(foo: Union[str, list[int]]): 3 ctx1hij

30 return foo 3 ctx1hij

31 

32 client = TestClient(app) 3 ctx1hij

33 

34 response = client.post("/", json="bar") 3 ctx1hij

35 assert response.status_code == 200, response.text 3 ctx1hij

36 assert response.json() == "bar" 3 ctx1hij

37 

38 response2 = client.post("/", json=[1, 2]) 3 ctx1hij

39 assert response2.status_code == 200, response2.text 3 ctx1hij

40 assert response2.json() == [1, 2] 3 ctx1hij

41 

42 

43def test_propagates_pydantic2_model_config(): 4 ctx1defg

44 app = FastAPI() 3 ctx1abc

45 

46 class Missing: 3 ctx1abc

47 def __bool__(self): 3 ctx1abc

48 return False 3 ctx1abc

49 

50 class EmbeddedModel(BaseModel): 3 ctx1abc

51 model_config = ConfigDict(arbitrary_types_allowed=True) 3 ctx1abc

52 value: Union[str, Missing] = Missing() 3 ctx1abc

53 

54 class Model(BaseModel): 3 ctx1abc

55 model_config = ConfigDict( 3 ctx1abc

56 arbitrary_types_allowed=True, 

57 ) 

58 value: Union[str, Missing] = Missing() 3 ctx1abc

59 embedded_model: EmbeddedModel = EmbeddedModel() 3 ctx1abc

60 

61 @app.post("/") 3 ctx1abc

62 def foo(req: Model) -> dict[str, Union[str, None]]: 3 ctx1abc

63 return { 3 ctx1abc

64 "value": req.value or None, 

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

66 } 

67 

68 client = TestClient(app) 3 ctx1abc

69 

70 response = client.post("/", json={}) 3 ctx1abc

71 assert response.status_code == 200, response.text 3 ctx1abc

72 assert response.json() == { 3 ctx1abc

73 "value": None, 

74 "embedded_value": None, 

75 } 

76 

77 response2 = client.post( 3 ctx1abc

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

79 ) 

80 assert response2.status_code == 200, response2.text 3 ctx1abc

81 assert response2.json() == { 3 ctx1abc

82 "value": "foo", 

83 "embedded_value": "bar", 

84 } 

85 

86 

87def test_is_bytes_sequence_annotation_union(): 4 ctx1defg

88 # For coverage 

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

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

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

92 assert is_bytes_sequence_annotation(Union[list[str], list[bytes]]) 3 ctx1wxy

93 

94 

95def test_is_uploadfile_sequence_annotation(): 4 ctx1defg

96 # For coverage 

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

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

99 # class "feature" 

100 assert is_uploadfile_sequence_annotation(Union[list[str], list[UploadFile]]) 3 ctx1zAB

101 

102 

103def test_serialize_sequence_value_with_optional_list(): 4 ctx1defg

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

105 from fastapi._compat import v2 3 ctx1klm

106 

107 field_info = FieldInfo(annotation=Union[list[str], None]) 3 ctx1klm

108 field = v2.ModelField(name="items", field_info=field_info) 3 ctx1klm

109 result = v2.serialize_sequence_value(field=field, value=["a", "b", "c"]) 3 ctx1klm

110 assert result == ["a", "b", "c"] 3 ctx1klm

111 assert isinstance(result, list) 3 ctx1klm

112 

113 

114@needs_py310 4 ctx1defg

115def test_serialize_sequence_value_with_optional_list_pipe_union(): 4 ctx1defg

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

117 from fastapi._compat import v2 3 ctx1nop

118 

119 field_info = FieldInfo(annotation=list[str] | None) 3 ctx1nop

120 field = v2.ModelField(name="items", field_info=field_info) 3 ctx1nop

121 result = v2.serialize_sequence_value(field=field, value=["a", "b", "c"]) 3 ctx1nop

122 assert result == ["a", "b", "c"] 3 ctx1nop

123 assert isinstance(result, list) 3 ctx1nop

124 

125 

126def test_serialize_sequence_value_with_none_first_in_union(): 4 ctx1defg

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

128 from fastapi._compat import v2 3 ctx1qrs

129 

130 field_info = FieldInfo(annotation=Union[None, list[str]]) 3 ctx1qrs

131 field = v2.ModelField(name="items", field_info=field_info) 3 ctx1qrs

132 result = v2.serialize_sequence_value(field=field, value=["x", "y"]) 3 ctx1qrs

133 assert result == ["x", "y"] 3 ctx1qrs

134 assert isinstance(result, list) 3 ctx1qrs