Coverage for tests / test_response_model_include_exclude.py: 100%

1from fastapi import FastAPI 4 ctx1adbc

2from fastapi.testclient import TestClient 4 ctx1adbc

3from pydantic import BaseModel 4 ctx1adbc

4 

5 

6class Model1(BaseModel): 4 ctx1adbc

7 foo: str 3 ctx1abc

8 bar: str 3 ctx1abc

9 

10 

11class Model2(BaseModel): 4 ctx1adbc

12 ref: Model1 3 ctx1abc

13 baz: str 3 ctx1abc

14 

15 

16class Model3(BaseModel): 4 ctx1adbc

17 name: str 3 ctx1abc

18 age: int 3 ctx1abc

19 ref2: Model2 3 ctx1abc

20 

21 

22app = FastAPI() 4 ctx1adbc

23 

24 

25@app.get( 4 ctx1adbc

26 "/simple_include", 

27 response_model=Model2, 

28 response_model_include={"baz": ..., "ref": {"foo"}}, 

29) 

30def simple_include(): 4 ctx1adbc

31 return Model2( 4 ctx1efgh

32 ref=Model1(foo="simple_include model foo", bar="simple_include model bar"), 

33 baz="simple_include model2 baz", 

34 ) 

35 

36 

37@app.get( 4 ctx1adbc

38 "/simple_include_dict", 

39 response_model=Model2, 

40 response_model_include={"baz": ..., "ref": {"foo"}}, 

41) 

42def simple_include_dict(): 4 ctx1adbc

43 return { 4 ctx1ijkl

44 "ref": { 

45 "foo": "simple_include_dict model foo", 

46 "bar": "simple_include_dict model bar", 

47 }, 

48 "baz": "simple_include_dict model2 baz", 

49 } 

50 

51 

52@app.get( 4 ctx1adbc

53 "/simple_exclude", 

54 response_model=Model2, 

55 response_model_exclude={"ref": {"bar"}}, 

56) 

57def simple_exclude(): 4 ctx1adbc

58 return Model2( 4 ctx1mnop

59 ref=Model1(foo="simple_exclude model foo", bar="simple_exclude model bar"), 

60 baz="simple_exclude model2 baz", 

61 ) 

62 

63 

64@app.get( 4 ctx1adbc

65 "/simple_exclude_dict", 

66 response_model=Model2, 

67 response_model_exclude={"ref": {"bar"}}, 

68) 

69def simple_exclude_dict(): 4 ctx1adbc

70 return { 4 ctx1qrst

71 "ref": { 

72 "foo": "simple_exclude_dict model foo", 

73 "bar": "simple_exclude_dict model bar", 

74 }, 

75 "baz": "simple_exclude_dict model2 baz", 

76 } 

77 

78 

79@app.get( 4 ctx1adbc

80 "/mixed", 

81 response_model=Model3, 

82 response_model_include={"ref2", "name"}, 

83 response_model_exclude={"ref2": {"baz"}}, 

84) 

85def mixed(): 4 ctx1adbc

86 return Model3( 4 ctx1uvwx

87 name="mixed model3 name", 

88 age=3, 

89 ref2=Model2( 

90 ref=Model1(foo="mixed model foo", bar="mixed model bar"), 

91 baz="mixed model2 baz", 

92 ), 

93 ) 

94 

95 

96@app.get( 4 ctx1adbc

97 "/mixed_dict", 

98 response_model=Model3, 

99 response_model_include={"ref2", "name"}, 

100 response_model_exclude={"ref2": {"baz"}}, 

101) 

102def mixed_dict(): 4 ctx1adbc

103 return { 4 ctx1yzAB

104 "name": "mixed_dict model3 name", 

105 "age": 3, 

106 "ref2": { 

107 "ref": {"foo": "mixed_dict model foo", "bar": "mixed_dict model bar"}, 

108 "baz": "mixed_dict model2 baz", 

109 }, 

110 } 

111 

112 

113client = TestClient(app) 4 ctx1adbc

114 

115 

116def test_nested_include_simple(): 4 ctx1adbc

117 response = client.get("/simple_include") 4 ctx1efgh

118 

119 assert response.status_code == 200, response.text 4 ctx1efgh

120 

121 assert response.json() == { 4 ctx1efgh

122 "baz": "simple_include model2 baz", 

123 "ref": {"foo": "simple_include model foo"}, 

124 } 

125 

126 

127def test_nested_include_simple_dict(): 4 ctx1adbc

128 response = client.get("/simple_include_dict") 4 ctx1ijkl

129 

130 assert response.status_code == 200, response.text 4 ctx1ijkl

131 

132 assert response.json() == { 4 ctx1ijkl

133 "baz": "simple_include_dict model2 baz", 

134 "ref": {"foo": "simple_include_dict model foo"}, 

135 } 

136 

137 

138def test_nested_exclude_simple(): 4 ctx1adbc

139 response = client.get("/simple_exclude") 4 ctx1mnop

140 assert response.status_code == 200, response.text 4 ctx1mnop

141 assert response.json() == { 4 ctx1mnop

142 "baz": "simple_exclude model2 baz", 

143 "ref": {"foo": "simple_exclude model foo"}, 

144 } 

145 

146 

147def test_nested_exclude_simple_dict(): 4 ctx1adbc

148 response = client.get("/simple_exclude_dict") 4 ctx1qrst

149 assert response.status_code == 200, response.text 4 ctx1qrst

150 assert response.json() == { 4 ctx1qrst

151 "baz": "simple_exclude_dict model2 baz", 

152 "ref": {"foo": "simple_exclude_dict model foo"}, 

153 } 

154 

155 

156def test_nested_include_mixed(): 4 ctx1adbc

157 response = client.get("/mixed") 4 ctx1uvwx

158 assert response.status_code == 200, response.text 4 ctx1uvwx

159 assert response.json() == { 4 ctx1uvwx

160 "name": "mixed model3 name", 

161 "ref2": { 

162 "ref": {"foo": "mixed model foo", "bar": "mixed model bar"}, 

163 }, 

164 } 

165 

166 

167def test_nested_include_mixed_dict(): 4 ctx1adbc

168 response = client.get("/mixed_dict") 4 ctx1yzAB

169 assert response.status_code == 200, response.text 4 ctx1yzAB

170 assert response.json() == { 4 ctx1yzAB

171 "name": "mixed_dict model3 name", 

172 "ref2": { 

173 "ref": {"foo": "mixed_dict model foo", "bar": "mixed_dict model bar"}, 

174 }, 

175 }