Coverage for tests/test_compat.py: 100%

1from typing import Any, Dict, List, Union 5 ctx1abcde

2 

3from fastapi import FastAPI, UploadFile 5 ctx1abcde

4from fastapi._compat import ( 5 ctx1abcde

5 ModelField, 

6 Undefined, 

7 _get_model_config, 

8 get_model_fields, 

9 is_bytes_sequence_annotation, 

10 is_scalar_field, 

11 is_uploadfile_sequence_annotation, 

12) 

13from fastapi.testclient import TestClient 5 ctx1abcde

14from pydantic import BaseConfig, BaseModel, ConfigDict 5 ctx1abcde

15from pydantic.fields import FieldInfo 5 ctx1abcde

16 

17from .utils import needs_pydanticv1, needs_pydanticv2 5 ctx1abcde

18 

19 

20@needs_pydanticv2 5 ctx1abcde

21def test_model_field_default_required(): 5 ctx1abcde

22 # For coverage 

23 field_info = FieldInfo(annotation=str) 5 ctx1zABCD

24 field = ModelField(name="foo", field_info=field_info) 5 ctx1zABCD

25 assert field.default is Undefined 5 ctx1zABCD

26 

27 

28@needs_pydanticv1 5 ctx1abcde

29def test_upload_file_dummy_with_info_plain_validator_function(): 5 ctx1abcde

30 # For coverage 

31 assert UploadFile.__get_pydantic_core_schema__(str, lambda x: None) == {} 5 ctx1EFGHI

32 

33 

34@needs_pydanticv1 5 ctx1abcde

35def test_union_scalar_list(): 5 ctx1abcde

36 # For coverage 

37 # TODO: there might not be a current valid code path that uses this, it would 

38 # potentially enable query parameters defined as both a scalar and a list 

39 # but that would require more refactors, also not sure it's really useful 

40 from fastapi._compat import is_pv1_scalar_field 5 ctx1pqrst

41 

42 field_info = FieldInfo() 5 ctx1pqrst

43 field = ModelField( 5 ctx1pqrst

44 name="foo", 

45 field_info=field_info, 

46 type_=Union[str, List[int]], 

47 class_validators={}, 

48 model_config=BaseConfig, 

49 ) 

50 assert not is_pv1_scalar_field(field) 5 ctx1pqrst

51 

52 

53@needs_pydanticv2 5 ctx1abcde

54def test_get_model_config(): 5 ctx1abcde

55 # For coverage in Pydantic v2 

56 class Foo(BaseModel): 5 ctx1klmno

57 model_config = ConfigDict(from_attributes=True) 5 ctx1klmno

58 

59 foo = Foo() 5 ctx1klmno

60 config = _get_model_config(foo) 5 ctx1klmno

61 assert config == {"from_attributes": True} 5 ctx1klmno

62 

63 

64def test_complex(): 5 ctx1abcde

65 app = FastAPI() 5 ctx1fghij

66 

67 @app.post("/") 5 ctx1fghij

68 def foo(foo: Union[str, List[int]]): 5 ctx1fghij

69 return foo 5 ctx1fghij

70 

71 client = TestClient(app) 5 ctx1fghij

72 

73 response = client.post("/", json="bar") 5 ctx1fghij

74 assert response.status_code == 200, response.text 5 ctx1fghij

75 assert response.json() == "bar" 5 ctx1fghij

76 

77 response2 = client.post("/", json=[1, 2]) 5 ctx1fghij

78 assert response2.status_code == 200, response2.text 5 ctx1fghij

79 assert response2.json() == [1, 2] 5 ctx1fghij

80 

81 

82def test_is_bytes_sequence_annotation_union(): 5 ctx1abcde

83 # For coverage 

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

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

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

87 assert is_bytes_sequence_annotation(Union[List[str], List[bytes]]) 5 ctx1JKLMN

88 

89 

90def test_is_uploadfile_sequence_annotation(): 5 ctx1abcde

91 # For coverage 

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

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

94 # class "feature" 

95 assert is_uploadfile_sequence_annotation(Union[List[str], List[UploadFile]]) 5 ctx1OPQRS

96 

97 

98def test_is_pv1_scalar_field(): 5 ctx1abcde

99 # For coverage 

100 class Model(BaseModel): 5 ctx1uvwxy

101 foo: Union[str, Dict[str, Any]] 5 ctx1uvwxy

102 

103 fields = get_model_fields(Model) 5 ctx1uvwxy

104 assert not is_scalar_field(fields[0]) 5 ctx1uvwxy