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

1from typing import Annotated, Optional 4 ctx1abcd

2 

3import pytest 4 ctx1abcd

4from fastapi import Cookie, FastAPI 4 ctx1abcd

5from fastapi.testclient import TestClient 4 ctx1abcd

6from inline_snapshot import snapshot 4 ctx1abcd

7from pydantic import BaseModel, Field 4 ctx1abcd

8 

9app = FastAPI() 4 ctx1abcd

10 

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

12# Without aliases 

13 

14 

15@app.get("/optional-str") 4 ctx1abcd

16async def read_optional_str(p: Annotated[Optional[str], Cookie()] = None): 4 ctx1abcd

17 return {"p": p} 6 ctx1eCfDgE

18 

19 

20class CookieModelOptionalStr(BaseModel): 4 ctx1abcd

21 p: Optional[str] = None 4 ctx1abcd

22 

23 

24@app.get("/model-optional-str") 4 ctx1abcd

25async def read_model_optional_str(p: Annotated[CookieModelOptionalStr, Cookie()]): 4 ctx1abcd

26 return {"p": p.p} 6 ctx1eCfDgE

27 

28 

29@pytest.mark.parametrize( 4 ctx1abcd

30 "path", 

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

32) 

33def test_optional_str_schema(path: str): 4 ctx1abcd

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

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( 4 ctx1abcd

50 "path", 

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

52) 

53def test_optional_str_missing(path: str): 4 ctx1abcd

54 client = TestClient(app) 3 ctx1CDE

55 response = client.get(path) 3 ctx1CDE

56 assert response.status_code == 200 3 ctx1CDE

57 assert response.json() == {"p": None} 3 ctx1CDE

58 

59 

60@pytest.mark.parametrize( 4 ctx1abcd

61 "path", 

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

63) 

64def test_optional_str(path: str): 4 ctx1abcd

65 client = TestClient(app) 3 ctx1efg

66 client.cookies.set("p", "hello") 3 ctx1efg

67 response = client.get(path) 3 ctx1efg

68 assert response.status_code == 200 3 ctx1efg

69 assert response.json() == {"p": "hello"} 3 ctx1efg

70 

71 

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

73# Alias 

74 

75 

76@app.get("/optional-alias") 4 ctx1abcd

77async def read_optional_alias( 4 ctx1abcd

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

79): 

80 return {"p": p} 9 ctx1hiFjkGlmH

81 

82 

83class CookieModelOptionalAlias(BaseModel): 4 ctx1abcd

84 p: Optional[str] = Field(None, alias="p_alias") 4 ctx1abcd

85 

86 

87@app.get("/model-optional-alias") 4 ctx1abcd

88async def read_model_optional_alias(p: Annotated[CookieModelOptionalAlias, Cookie()]): 4 ctx1abcd

89 return {"p": p.p} 9 ctx1hiFjkGlmH

90 

91 

92@pytest.mark.parametrize( 4 ctx1abcd

93 "path", 

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

95) 

96def test_optional_str_alias_schema(path: str): 4 ctx1abcd

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

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( 4 ctx1abcd

113 "path", 

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

115) 

116def test_optional_alias_missing(path: str): 4 ctx1abcd

117 client = TestClient(app) 3 ctx1FGH

118 response = client.get(path) 3 ctx1FGH

119 assert response.status_code == 200 3 ctx1FGH

120 assert response.json() == {"p": None} 3 ctx1FGH

121 

122 

123@pytest.mark.parametrize( 4 ctx1abcd

124 "path", 

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

126) 

127def test_optional_alias_by_name(path: str): 4 ctx1abcd

128 client = TestClient(app) 3 ctx1ikm

129 client.cookies.set("p", "hello") 3 ctx1ikm

130 response = client.get(path) 3 ctx1ikm

131 assert response.status_code == 200 3 ctx1ikm

132 assert response.json() == {"p": None} 3 ctx1ikm

133 

134 

135@pytest.mark.parametrize( 4 ctx1abcd

136 "path", 

137 [ 

138 "/optional-alias", 

139 "/model-optional-alias", 

140 ], 

141) 

142def test_optional_alias_by_alias(path: str): 4 ctx1abcd

143 client = TestClient(app) 3 ctx1hjl

144 client.cookies.set("p_alias", "hello") 3 ctx1hjl

145 response = client.get(path) 3 ctx1hjl

146 assert response.status_code == 200 3 ctx1hjl

147 assert response.json() == {"p": "hello"} 3 ctx1hjl

148 

149 

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

151# Validation alias 

152 

153 

154@app.get("/optional-validation-alias") 4 ctx1abcd

155def read_optional_validation_alias( 4 ctx1abcd

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

157): 

158 return {"p": p} 9 ctx1noIpqJrsK

159 

160 

161class CookieModelOptionalValidationAlias(BaseModel): 4 ctx1abcd

162 p: Optional[str] = Field(None, validation_alias="p_val_alias") 4 ctx1abcd

163 

164 

165@app.get("/model-optional-validation-alias") 4 ctx1abcd

166def read_model_optional_validation_alias( 4 ctx1abcd

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

168): 

169 return {"p": p.p} 9 ctx1noIpqJrsK

170 

171 

172@pytest.mark.parametrize( 4 ctx1abcd

173 "path", 

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

175) 

176def test_optional_validation_alias_schema(path: str): 4 ctx1abcd

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

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( 4 ctx1abcd

193 "path", 

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

195) 

196def test_optional_validation_alias_missing(path: str): 4 ctx1abcd

197 client = TestClient(app) 3 ctx1IJK

198 response = client.get(path) 3 ctx1IJK

199 assert response.status_code == 200 3 ctx1IJK

200 assert response.json() == {"p": None} 3 ctx1IJK

201 

202 

203@pytest.mark.parametrize( 4 ctx1abcd

204 "path", 

205 [ 

206 "/optional-validation-alias", 

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

208 ], 

209) 

210def test_optional_validation_alias_by_name(path: str): 4 ctx1abcd

211 client = TestClient(app) 3 ctx1npr

212 client.cookies.set("p", "hello") 3 ctx1npr

213 response = client.get(path) 3 ctx1npr

214 assert response.status_code == 200 3 ctx1npr

215 assert response.json() == {"p": None} 3 ctx1npr

216 

217 

218@pytest.mark.parametrize( 4 ctx1abcd

219 "path", 

220 [ 

221 "/optional-validation-alias", 

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

223 ], 

224) 

225def test_optional_validation_alias_by_validation_alias(path: str): 4 ctx1abcd

226 client = TestClient(app) 3 ctx1oqs

227 client.cookies.set("p_val_alias", "hello") 3 ctx1oqs

228 response = client.get(path) 3 ctx1oqs

229 assert response.status_code == 200 3 ctx1oqs

230 assert response.json() == {"p": "hello"} 3 ctx1oqs

231 

232 

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

234# Alias and validation alias 

235 

236 

237@app.get("/optional-alias-and-validation-alias") 4 ctx1abcd

238def read_optional_alias_and_validation_alias( 4 ctx1abcd

239 p: Annotated[ 

240 Optional[str], Cookie(alias="p_alias", validation_alias="p_val_alias") 

241 ] = None, 

242): 

243 return {"p": p} 12 ctx1tuvLwxyMzABN

244 

245 

246class CookieModelOptionalAliasAndValidationAlias(BaseModel): 4 ctx1abcd

247 p: Optional[str] = Field(None, alias="p_alias", validation_alias="p_val_alias") 4 ctx1abcd

248 

249 

250@app.get("/model-optional-alias-and-validation-alias") 4 ctx1abcd

251def read_model_optional_alias_and_validation_alias( 4 ctx1abcd

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

253): 

254 return {"p": p.p} 12 ctx1tuvLwxyMzABN

255 

256 

257@pytest.mark.parametrize( 4 ctx1abcd

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): 4 ctx1abcd

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

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( 4 ctx1abcd

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): 4 ctx1abcd

288 client = TestClient(app) 3 ctx1LMN

289 response = client.get(path) 3 ctx1LMN

290 assert response.status_code == 200 3 ctx1LMN

291 assert response.json() == {"p": None} 3 ctx1LMN

292 

293 

294@pytest.mark.parametrize( 4 ctx1abcd

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): 4 ctx1abcd

302 client = TestClient(app) 3 ctx1uxA

303 client.cookies.set("p", "hello") 3 ctx1uxA

304 response = client.get(path) 3 ctx1uxA

305 assert response.status_code == 200 3 ctx1uxA

306 assert response.json() == {"p": None} 3 ctx1uxA

307 

308 

309@pytest.mark.parametrize( 4 ctx1abcd

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): 4 ctx1abcd

317 client = TestClient(app) 3 ctx1twz

318 client.cookies.set("p_alias", "hello") 3 ctx1twz

319 response = client.get(path) 3 ctx1twz

320 assert response.status_code == 200 3 ctx1twz

321 assert response.json() == {"p": None} 3 ctx1twz

322 

323 

324@pytest.mark.parametrize( 4 ctx1abcd

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): 4 ctx1abcd

332 client = TestClient(app) 3 ctx1vyB

333 client.cookies.set("p_val_alias", "hello") 3 ctx1vyB

334 response = client.get(path) 3 ctx1vyB

335 assert response.status_code == 200 3 ctx1vyB

336 assert response.json() == {"p": "hello"} 3 ctx1vyB