Coverage for tests / test_request_params / test_cookie / test_optional_str.py: 100%

131 statements  

« prev     ^ index     » next       coverage.py v7.13.3, created at 2026-04-06 01:24 +0000

1from typing import Annotated 1abcd

2 

3import pytest 1abcd

4from fastapi import Cookie, FastAPI 1abcd

5from fastapi.testclient import TestClient 1abcd

6from inline_snapshot import snapshot 1abcd

7from pydantic import BaseModel, Field 1abcd

8 

9app = FastAPI() 1abcd

10 

11# ===================================================================================== 

12# Without aliases 

13 

14 

15@app.get("/optional-str") 1abcd

16async def read_optional_str(p: Annotated[str | None, Cookie()] = None): 1abcd

17 return {"p": p} 1e45f6g7

18 

19 

20class CookieModelOptionalStr(BaseModel): 1abcd

21 p: str | None = None 1abcd

22 

23 

24@app.get("/model-optional-str") 1abcd

25async def read_model_optional_str(p: Annotated[CookieModelOptionalStr, Cookie()]): 1abcd

26 return {"p": p.p} 2h 8 gb9 i ! j #

27 

28 

29@pytest.mark.parametrize( 1abcd

30 "path", 

31 ["/optional-str", "/model-optional-str"], 

32) 

33def test_optional_str_schema(path: str): 1abcd

34 assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot( 2hbibjbkblbmbnb

35 [ 

36 { 

37 "required": False, 

38 "schema": { 

39 "anyOf": [{"type": "string"}, {"type": "null"}], 

40 "title": "P", 

41 }, 

42 "name": "p", 

43 "in": "cookie", 

44 } 

45 ] 

46 ) 

47 

48 

49@pytest.mark.parametrize( 1abcd

50 "path", 

51 ["/optional-str", "/model-optional-str"], 

52) 

53def test_optional_str_missing(path: str): 1abcd

54 client = TestClient(app) 18495!6#7

55 response = client.get(path) 18495!6#7

56 assert response.status_code == 200 18495!6#7

57 assert response.json() == {"p": None} 18495!6#7

58 

59 

60@pytest.mark.parametrize( 1abcd

61 "path", 

62 ["/optional-str", "/model-optional-str"], 

63) 

64def test_optional_str(path: str): 1abcd

65 client = TestClient(app) 1he$ifjg

66 client.cookies.set("p", "hello") 1he$ifjg

67 response = client.get(path) 1he$ifjg

68 assert response.status_code == 200 1he$ifjg

69 assert response.json() == {"p": "hello"} 1he$ifjg

70 

71 

72# ===================================================================================== 

73# Alias 

74 

75 

76@app.get("/optional-alias") 1abcd

77async def read_optional_alias( 1abcd

78 p: Annotated[str | None, Cookie(alias="p_alias")] = None, 

79): 

80 return {"p": p} 1kl%m'no(pq)

81 

82 

83class CookieModelOptionalAlias(BaseModel): 1abcd

84 p: str | None = Field(None, alias="p_alias") 1abcd

85 

86 

87@app.get("/model-optional-alias") 1abcd

88async def read_model_optional_alias(p: Annotated[CookieModelOptionalAlias, Cookie()]): 1abcd

89 return {"p": p.p} 2r s * obpbt u + v w ,

90 

91 

92@pytest.mark.parametrize( 1abcd

93 "path", 

94 ["/optional-alias", "/model-optional-alias"], 

95) 

96def test_optional_str_alias_schema(path: str): 1abcd

97 assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot( 2qbrbsbtbubvbwb

98 [ 

99 { 

100 "required": False, 

101 "schema": { 

102 "anyOf": [{"type": "string"}, {"type": "null"}], 

103 "title": "P Alias", 

104 }, 

105 "name": "p_alias", 

106 "in": "cookie", 

107 } 

108 ] 

109 ) 

110 

111 

112@pytest.mark.parametrize( 1abcd

113 "path", 

114 ["/optional-alias", "/model-optional-alias"], 

115) 

116def test_optional_alias_missing(path: str): 1abcd

117 client = TestClient(app) 1*%'+(,)

118 response = client.get(path) 1*%'+(,)

119 assert response.status_code == 200 1*%'+(,)

120 assert response.json() == {"p": None} 1*%'+(,)

121 

122 

123@pytest.mark.parametrize( 1abcd

124 "path", 

125 ["/optional-alias", "/model-optional-alias"], 

126) 

127def test_optional_alias_by_name(path: str): 1abcd

128 client = TestClient(app) 1sl-uowq

129 client.cookies.set("p", "hello") 1sl-uowq

130 response = client.get(path) 1sl-uowq

131 assert response.status_code == 200 1sl-uowq

132 assert response.json() == {"p": None} 1sl-uowq

133 

134 

135@pytest.mark.parametrize( 1abcd

136 "path", 

137 [ 

138 "/optional-alias", 

139 "/model-optional-alias", 

140 ], 

141) 

142def test_optional_alias_by_alias(path: str): 1abcd

143 client = TestClient(app) 1rkmtnvp

144 client.cookies.set("p_alias", "hello") 1rkmtnvp

145 response = client.get(path) 1rkmtnvp

146 assert response.status_code == 200 1rkmtnvp

147 assert response.json() == {"p": "hello"} 1rkmtnvp

148 

149 

150# ===================================================================================== 

151# Validation alias 

152 

153 

154@app.get("/optional-validation-alias") 1abcd

155def read_optional_validation_alias( 1abcd

156 p: Annotated[str | None, Cookie(validation_alias="p_val_alias")] = None, 

157): 

158 return {"p": p} 1xy.z/AB:CD;

159 

160 

161class CookieModelOptionalValidationAlias(BaseModel): 1abcd

162 p: str | None = Field(None, validation_alias="p_val_alias") 1abcd

163 

164 

165@app.get("/model-optional-validation-alias") 1abcd

166def read_model_optional_validation_alias( 1abcd

167 p: Annotated[CookieModelOptionalValidationAlias, Cookie()], 

168): 

169 return {"p": p.p} 2E F = xbG H ? I J @

170 

171 

172@pytest.mark.parametrize( 1abcd

173 "path", 

174 ["/optional-validation-alias", "/model-optional-validation-alias"], 

175) 

176def test_optional_validation_alias_schema(path: str): 1abcd

177 assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot( 2ybzbAbBbCbDbEbFb

178 [ 

179 { 

180 "required": False, 

181 "schema": { 

182 "anyOf": [{"type": "string"}, {"type": "null"}], 

183 "title": "P Val Alias", 

184 }, 

185 "name": "p_val_alias", 

186 "in": "cookie", 

187 } 

188 ] 

189 ) 

190 

191 

192@pytest.mark.parametrize( 1abcd

193 "path", 

194 ["/optional-validation-alias", "/model-optional-validation-alias"], 

195) 

196def test_optional_validation_alias_missing(path: str): 1abcd

197 client = TestClient(app) 1=./?:@;

198 response = client.get(path) 1=./?:@;

199 assert response.status_code == 200 1=./?:@;

200 assert response.json() == {"p": None} 1=./?:@;

201 

202 

203@pytest.mark.parametrize( 1abcd

204 "path", 

205 [ 

206 "/optional-validation-alias", 

207 "/model-optional-validation-alias", 

208 ], 

209) 

210def test_optional_validation_alias_by_name(path: str): 1abcd

211 client = TestClient(app) 1Ex[zGAIC

212 client.cookies.set("p", "hello") 1Ex[zGAIC

213 response = client.get(path) 1Ex[zGAIC

214 assert response.status_code == 200 1Ex[zGAIC

215 assert response.json() == {"p": None} 1Ex[zGAIC

216 

217 

218@pytest.mark.parametrize( 1abcd

219 "path", 

220 [ 

221 "/optional-validation-alias", 

222 "/model-optional-validation-alias", 

223 ], 

224) 

225def test_optional_validation_alias_by_validation_alias(path: str): 1abcd

226 client = TestClient(app) 1Fy]^HBJD

227 client.cookies.set("p_val_alias", "hello") 1Fy]^HBJD

228 response = client.get(path) 1Fy]^HBJD

229 assert response.status_code == 200 1Fy]^HBJD

230 assert response.json() == {"p": "hello"} 1Fy]^HBJD

231 

232 

233# ===================================================================================== 

234# Alias and validation alias 

235 

236 

237@app.get("/optional-alias-and-validation-alias") 1abcd

238def read_optional_alias_and_validation_alias( 1abcd

239 p: Annotated[ 

240 str | None, Cookie(alias="p_alias", validation_alias="p_val_alias") 

241 ] = None, 

242): 

243 return {"p": p} 1KLM_N`OPQ{RST|

244 

245 

246class CookieModelOptionalAliasAndValidationAlias(BaseModel): 1abcd

247 p: str | None = Field(None, alias="p_alias", validation_alias="p_val_alias") 1abcd

248 

249 

250@app.get("/model-optional-alias-and-validation-alias") 1abcd

251def read_model_optional_alias_and_validation_alias( 1abcd

252 p: Annotated[CookieModelOptionalAliasAndValidationAlias, Cookie()], 

253): 

254 return {"p": p.p} 2U V W } X ~ Y Z 0 ab1 2 3 bb

255 

256 

257@pytest.mark.parametrize( 1abcd

258 "path", 

259 [ 

260 "/optional-alias-and-validation-alias", 

261 "/model-optional-alias-and-validation-alias", 

262 ], 

263) 

264def test_optional_alias_and_validation_alias_schema(path: str): 1abcd

265 assert app.openapi()["paths"][path]["get"]["parameters"] == snapshot( 2GbHbIbJbKbLbMbNb

266 [ 

267 { 

268 "required": False, 

269 "schema": { 

270 "anyOf": [{"type": "string"}, {"type": "null"}], 

271 "title": "P Val Alias", 

272 }, 

273 "name": "p_val_alias", 

274 "in": "cookie", 

275 } 

276 ] 

277 ) 

278 

279 

280@pytest.mark.parametrize( 1abcd

281 "path", 

282 [ 

283 "/optional-alias-and-validation-alias", 

284 "/model-optional-alias-and-validation-alias", 

285 ], 

286) 

287def test_optional_alias_and_validation_alias_missing(path: str): 1abcd

288 client = TestClient(app) 2} _ ~ ` ab{ bb|

289 response = client.get(path) 2} _ ~ ` ab{ bb|

290 assert response.status_code == 200 2} _ ~ ` ab{ bb|

291 assert response.json() == {"p": None} 2} _ ~ ` ab{ bb|

292 

293 

294@pytest.mark.parametrize( 1abcd

295 "path", 

296 [ 

297 "/optional-alias-and-validation-alias", 

298 "/model-optional-alias-and-validation-alias", 

299 ], 

300) 

301def test_optional_alias_and_validation_alias_by_name(path: str): 1abcd

302 client = TestClient(app) 2V L cbdbZ P 2 S

303 client.cookies.set("p", "hello") 2V L cbdbZ P 2 S

304 response = client.get(path) 2V L cbdbZ P 2 S

305 assert response.status_code == 200 2V L cbdbZ P 2 S

306 assert response.json() == {"p": None} 2V L cbdbZ P 2 S

307 

308 

309@pytest.mark.parametrize( 1abcd

310 "path", 

311 [ 

312 "/optional-alias-and-validation-alias", 

313 "/model-optional-alias-and-validation-alias", 

314 ], 

315) 

316def test_optional_alias_and_validation_alias_by_alias(path: str): 1abcd

317 client = TestClient(app) 2U K ebfbY O 1 R

318 client.cookies.set("p_alias", "hello") 2U K ebfbY O 1 R

319 response = client.get(path) 2U K ebfbY O 1 R

320 assert response.status_code == 200 2U K ebfbY O 1 R

321 assert response.json() == {"p": None} 2U K ebfbY O 1 R

322 

323 

324@pytest.mark.parametrize( 1abcd

325 "path", 

326 [ 

327 "/optional-alias-and-validation-alias", 

328 "/model-optional-alias-and-validation-alias", 

329 ], 

330) 

331def test_optional_alias_and_validation_alias_by_validation_alias(path: str): 1abcd

332 client = TestClient(app) 1WMXN0Q3T

333 client.cookies.set("p_val_alias", "hello") 1WMXN0Q3T

334 response = client.get(path) 1WMXN0Q3T

335 assert response.status_code == 200 1WMXN0Q3T

336 assert response.json() == {"p": "hello"} 1WMXN0Q3T