Coverage for tests / test_compat.py: 100%

1from fastapi import FastAPI, UploadFile 4 ctx1defg

2from fastapi._compat import ( 4 ctx1defg

3 Undefined, 

4 is_uploadfile_sequence_annotation, 

5) 

6from fastapi._compat.shared import is_bytes_sequence_annotation 4 ctx1defg

7from fastapi.testclient import TestClient 4 ctx1defg

8from pydantic import BaseModel, ConfigDict 4 ctx1defg

9from pydantic.fields import FieldInfo 4 ctx1defg

10 

11 

12def test_model_field_default_required(): 4 ctx1defg

13 from fastapi._compat import v2 3 ctx1tuv

14 

15 # For coverage 

16 field_info = FieldInfo(annotation=str) 3 ctx1tuv

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

18 assert field.default is Undefined 3 ctx1tuv

19 

20 

21def test_complex(): 4 ctx1defg

22 app = FastAPI() 3 ctx1hij

23 

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

25 def foo(foo: str | list[int]): 3 ctx1hij

26 return foo 3 ctx1hij

27 

28 client = TestClient(app) 3 ctx1hij

29 

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

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

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

33 

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

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

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

37 

38 

39def test_propagates_pydantic2_model_config(): 4 ctx1defg

40 app = FastAPI() 3 ctx1abc

41 

42 class Missing: 3 ctx1abc

43 def __bool__(self): 3 ctx1abc

44 return False 3 ctx1abc

45 

46 class EmbeddedModel(BaseModel): 3 ctx1abc

47 model_config = ConfigDict(arbitrary_types_allowed=True) 3 ctx1abc

48 value: str | Missing = Missing() 3 ctx1abc

49 

50 class Model(BaseModel): 3 ctx1abc

51 model_config = ConfigDict( 3 ctx1abc

52 arbitrary_types_allowed=True, 

53 ) 

54 value: str | Missing = Missing() 3 ctx1abc

55 embedded_model: EmbeddedModel = EmbeddedModel() 3 ctx1abc

56 

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

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

59 return { 3 ctx1abc

60 "value": req.value or None, 

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

62 } 

63 

64 client = TestClient(app) 3 ctx1abc

65 

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

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

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

69 "value": None, 

70 "embedded_value": None, 

71 } 

72 

73 response2 = client.post( 3 ctx1abc

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

75 ) 

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

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

78 "value": "foo", 

79 "embedded_value": "bar", 

80 } 

81 

82 

83def test_is_bytes_sequence_annotation_union(): 4 ctx1defg

84 # For coverage 

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

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

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

88 assert is_bytes_sequence_annotation(list[str] | list[bytes]) 3 ctx1wxy

89 

90 

91def test_is_uploadfile_sequence_annotation(): 4 ctx1defg

92 # For coverage 

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

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

95 # class "feature" 

96 assert is_uploadfile_sequence_annotation(list[str] | list[UploadFile]) 3 ctx1zAB

97 

98 

99def test_serialize_sequence_value_with_optional_list(): 4 ctx1defg

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

101 from fastapi._compat import v2 3 ctx1nop

102 

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

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

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

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

107 assert isinstance(result, list) 3 ctx1nop

108 

109 

110def test_serialize_sequence_value_with_optional_list_pipe_union(): 4 ctx1defg

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

112 from fastapi._compat import v2 3 ctx1qrs

113 

114 field_info = FieldInfo(annotation=list[str] | None) 3 ctx1qrs

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

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

117 assert result == ["a", "b", "c"] 3 ctx1qrs

118 assert isinstance(result, list) 3 ctx1qrs

119 

120 

121def test_serialize_sequence_value_with_none_first_in_union(): 4 ctx1defg

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

123 from typing import Union 3 ctx1klm

124 

125 from fastapi._compat import v2 3 ctx1klm

126 

127 # Use Union[None, list[str]] to ensure None comes first in the union args 

128 field_info = FieldInfo(annotation=Union[None, list[str]]) # noqa: UP007 3 ctx1klm

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

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

131 assert result == ["x", "y"] 3 ctx1klm

132 assert isinstance(result, list) 3 ctx1klm