Coverage for tests / test_request_params / test_file / test_optional_list.py: 100%

1from typing import Annotated 4 ctx1abcd

2 

3import pytest 4 ctx1abcd

4from fastapi import FastAPI, File, UploadFile 4 ctx1abcd

5from fastapi.testclient import TestClient 4 ctx1abcd

6 

7from .utils import get_body_model_name 4 ctx1abcd

8 

9app = FastAPI() 4 ctx1abcd

10 

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

12# Without aliases 

13 

14 

15@app.post("/optional-list-bytes") 4 ctx1abcd

16async def read_optional_list_bytes(p: Annotated[list[bytes] | None, File()] = None): 4 ctx1abcd

17 return {"file_size": [len(file) for file in p] if p else None} 6 ctx1efghij

18 

19 

20@app.post("/optional-list-uploadfile") 4 ctx1abcd

21async def read_optional_list_uploadfile( 4 ctx1abcd

22 p: Annotated[list[UploadFile] | None, File()] = None, 

23): 

24 return {"file_size": [file.size for file in p] if p else None} 6 ctx1efghij

25 

26 

27@pytest.mark.parametrize( 4 ctx1abcd

28 "path", 

29 [ 

30 "/optional-list-bytes", 

31 "/optional-list-uploadfile", 

32 ], 

33) 

34def test_optional_list_schema(path: str): 4 ctx1abcd

35 openapi = app.openapi() 3 ctx1OPQ

36 body_model_name = get_body_model_name(openapi, path) 3 ctx1OPQ

37 

38 assert app.openapi()["components"]["schemas"][body_model_name] == { 3 ctx1OPQ

39 "properties": { 

40 "p": { 

41 "anyOf": [ 

42 { 

43 "type": "array", 

44 "items": { 

45 "type": "string", 

46 "contentMediaType": "application/octet-stream", 

47 }, 

48 }, 

49 {"type": "null"}, 

50 ], 

51 "title": "P", 

52 } 

53 }, 

54 "title": body_model_name, 

55 "type": "object", 

56 } 

57 

58 

59@pytest.mark.parametrize( 4 ctx1abcd

60 "path", 

61 [ 

62 "/optional-list-bytes", 

63 "/optional-list-uploadfile", 

64 ], 

65) 

66def test_optional_list_missing(path: str): 4 ctx1abcd

67 client = TestClient(app) 3 ctx1fhj

68 response = client.post(path) 3 ctx1fhj

69 assert response.status_code == 200, response.text 3 ctx1fhj

70 assert response.json() == {"file_size": None} 3 ctx1fhj

71 

72 

73@pytest.mark.parametrize( 4 ctx1abcd

74 "path", 

75 [ 

76 "/optional-list-bytes", 

77 "/optional-list-uploadfile", 

78 ], 

79) 

80def test_optional_list(path: str): 4 ctx1abcd

81 client = TestClient(app) 3 ctx1egi

82 response = client.post(path, files=[("p", b"hello"), ("p", b"world")]) 3 ctx1egi

83 assert response.status_code == 200 3 ctx1egi

84 assert response.json() == {"file_size": [5, 5]} 3 ctx1egi

85 

86 

87# ===================================================================================== 

88# Alias 

89 

90 

91@app.post("/optional-list-bytes-alias") 4 ctx1abcd

92async def read_optional_list_bytes_alias( 4 ctx1abcd

93 p: Annotated[list[bytes] | None, File(alias="p_alias")] = None, 

94): 

95 return {"file_size": [len(file) for file in p] if p else None} 9 ctx1klmnopqrs

96 

97 

98@app.post("/optional-list-uploadfile-alias") 4 ctx1abcd

99async def read_optional_list_uploadfile_alias( 4 ctx1abcd

100 p: Annotated[list[UploadFile] | None, File(alias="p_alias")] = None, 

101): 

102 return {"file_size": [file.size for file in p] if p else None} 9 ctx1klmnopqrs

103 

104 

105@pytest.mark.parametrize( 4 ctx1abcd

106 "path", 

107 [ 

108 "/optional-list-bytes-alias", 

109 "/optional-list-uploadfile-alias", 

110 ], 

111) 

112def test_optional_list_alias_schema(path: str): 4 ctx1abcd

113 openapi = app.openapi() 3 ctx1RST

114 body_model_name = get_body_model_name(openapi, path) 3 ctx1RST

115 

116 assert app.openapi()["components"]["schemas"][body_model_name] == { 3 ctx1RST

117 "properties": { 

118 "p_alias": { 

119 "anyOf": [ 

120 { 

121 "type": "array", 

122 "items": { 

123 "type": "string", 

124 "contentMediaType": "application/octet-stream", 

125 }, 

126 }, 

127 {"type": "null"}, 

128 ], 

129 "title": "P Alias", 

130 } 

131 }, 

132 "title": body_model_name, 

133 "type": "object", 

134 } 

135 

136 

137@pytest.mark.parametrize( 4 ctx1abcd

138 "path", 

139 [ 

140 "/optional-list-bytes-alias", 

141 "/optional-list-uploadfile-alias", 

142 ], 

143) 

144def test_optional_list_alias_missing(path: str): 4 ctx1abcd

145 client = TestClient(app) 3 ctx1mps

146 response = client.post(path) 3 ctx1mps

147 assert response.status_code == 200 3 ctx1mps

148 assert response.json() == {"file_size": None} 3 ctx1mps

149 

150 

151@pytest.mark.parametrize( 4 ctx1abcd

152 "path", 

153 [ 

154 "/optional-list-bytes-alias", 

155 "/optional-list-uploadfile-alias", 

156 ], 

157) 

158def test_optional_list_alias_by_name(path: str): 4 ctx1abcd

159 client = TestClient(app) 3 ctx1lor

160 response = client.post(path, files=[("p", b"hello"), ("p", b"world")]) 3 ctx1lor

161 assert response.status_code == 200, response.text 3 ctx1lor

162 assert response.json() == {"file_size": None} 3 ctx1lor

163 

164 

165@pytest.mark.parametrize( 4 ctx1abcd

166 "path", 

167 [ 

168 "/optional-list-bytes-alias", 

169 "/optional-list-uploadfile-alias", 

170 ], 

171) 

172def test_optional_list_alias_by_alias(path: str): 4 ctx1abcd

173 client = TestClient(app) 3 ctx1knq

174 response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")]) 3 ctx1knq

175 assert response.status_code == 200, response.text 3 ctx1knq

176 assert response.json() == {"file_size": [5, 5]} 3 ctx1knq

177 

178 

179# ===================================================================================== 

180# Validation alias 

181 

182 

183@app.post("/optional-list-bytes-validation-alias") 4 ctx1abcd

184def read_optional_list_bytes_validation_alias( 4 ctx1abcd

185 p: Annotated[list[bytes] | None, File(validation_alias="p_val_alias")] = None, 

186): 

187 return {"file_size": [len(file) for file in p] if p else None} 9 ctx1tuvwxyzAB

188 

189 

190@app.post("/optional-list-uploadfile-validation-alias") 4 ctx1abcd

191def read_optional_list_uploadfile_validation_alias( 4 ctx1abcd

192 p: Annotated[list[UploadFile] | None, File(validation_alias="p_val_alias")] = None, 

193): 

194 return {"file_size": [file.size for file in p] if p else None} 9 ctx1tuvwxyzAB

195 

196 

197@pytest.mark.parametrize( 4 ctx1abcd

198 "path", 

199 [ 

200 "/optional-list-bytes-validation-alias", 

201 "/optional-list-uploadfile-validation-alias", 

202 ], 

203) 

204def test_optional_validation_alias_schema(path: str): 4 ctx1abcd

205 openapi = app.openapi() 3 ctx1UVW

206 body_model_name = get_body_model_name(openapi, path) 3 ctx1UVW

207 

208 assert app.openapi()["components"]["schemas"][body_model_name] == { 3 ctx1UVW

209 "properties": { 

210 "p_val_alias": { 

211 "anyOf": [ 

212 { 

213 "type": "array", 

214 "items": { 

215 "type": "string", 

216 "contentMediaType": "application/octet-stream", 

217 }, 

218 }, 

219 {"type": "null"}, 

220 ], 

221 "title": "P Val Alias", 

222 } 

223 }, 

224 "title": body_model_name, 

225 "type": "object", 

226 } 

227 

228 

229@pytest.mark.parametrize( 4 ctx1abcd

230 "path", 

231 [ 

232 "/optional-list-bytes-validation-alias", 

233 "/optional-list-uploadfile-validation-alias", 

234 ], 

235) 

236def test_optional_validation_alias_missing(path: str): 4 ctx1abcd

237 client = TestClient(app) 3 ctx1vyB

238 response = client.post(path) 3 ctx1vyB

239 assert response.status_code == 200 3 ctx1vyB

240 assert response.json() == {"file_size": None} 3 ctx1vyB

241 

242 

243@pytest.mark.parametrize( 4 ctx1abcd

244 "path", 

245 [ 

246 "/optional-list-bytes-validation-alias", 

247 "/optional-list-uploadfile-validation-alias", 

248 ], 

249) 

250def test_optional_validation_alias_by_name(path: str): 4 ctx1abcd

251 client = TestClient(app) 3 ctx1twz

252 response = client.post(path, files=[("p", b"hello"), ("p", b"world")]) 3 ctx1twz

253 assert response.status_code == 200, response.text 3 ctx1twz

254 assert response.json() == {"file_size": None} 3 ctx1twz

255 

256 

257@pytest.mark.parametrize( 4 ctx1abcd

258 "path", 

259 [ 

260 "/optional-list-bytes-validation-alias", 

261 "/optional-list-uploadfile-validation-alias", 

262 ], 

263) 

264def test_optional_validation_alias_by_validation_alias(path: str): 4 ctx1abcd

265 client = TestClient(app) 3 ctx1uxA

266 response = client.post( 3 ctx1uxA

267 path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")] 

268 ) 

269 assert response.status_code == 200, response.text 3 ctx1uxA

270 assert response.json() == {"file_size": [5, 5]} 3 ctx1uxA

271 

272 

273# ===================================================================================== 

274# Alias and validation alias 

275 

276 

277@app.post("/optional-list-bytes-alias-and-validation-alias") 4 ctx1abcd

278def read_optional_list_bytes_alias_and_validation_alias( 4 ctx1abcd

279 p: Annotated[ 

280 list[bytes] | None, File(alias="p_alias", validation_alias="p_val_alias") 

281 ] = None, 

282): 

283 return {"file_size": [len(file) for file in p] if p else None} 12 ctx1CDEFGHIJKLMN

284 

285 

286@app.post("/optional-list-uploadfile-alias-and-validation-alias") 4 ctx1abcd

287def read_optional_list_uploadfile_alias_and_validation_alias( 4 ctx1abcd

288 p: Annotated[ 

289 list[UploadFile] | None, 

290 File(alias="p_alias", validation_alias="p_val_alias"), 

291 ] = None, 

292): 

293 return {"file_size": [file.size for file in p] if p else None} 12 ctx1CDEFGHIJKLMN

294 

295 

296@pytest.mark.parametrize( 4 ctx1abcd

297 "path", 

298 [ 

299 "/optional-list-bytes-alias-and-validation-alias", 

300 "/optional-list-uploadfile-alias-and-validation-alias", 

301 ], 

302) 

303def test_optional_list_alias_and_validation_alias_schema(path: str): 4 ctx1abcd

304 openapi = app.openapi() 3 ctx1XYZ

305 body_model_name = get_body_model_name(openapi, path) 3 ctx1XYZ

306 

307 assert app.openapi()["components"]["schemas"][body_model_name] == { 3 ctx1XYZ

308 "properties": { 

309 "p_val_alias": { 

310 "anyOf": [ 

311 { 

312 "type": "array", 

313 "items": { 

314 "type": "string", 

315 "contentMediaType": "application/octet-stream", 

316 }, 

317 }, 

318 {"type": "null"}, 

319 ], 

320 "title": "P Val Alias", 

321 } 

322 }, 

323 "title": body_model_name, 

324 "type": "object", 

325 } 

326 

327 

328@pytest.mark.parametrize( 4 ctx1abcd

329 "path", 

330 [ 

331 "/optional-list-bytes-alias-and-validation-alias", 

332 "/optional-list-uploadfile-alias-and-validation-alias", 

333 ], 

334) 

335def test_optional_list_alias_and_validation_alias_missing(path: str): 4 ctx1abcd

336 client = TestClient(app) 3 ctx1FJN

337 response = client.post(path) 3 ctx1FJN

338 assert response.status_code == 200 3 ctx1FJN

339 assert response.json() == {"file_size": None} 3 ctx1FJN

340 

341 

342@pytest.mark.parametrize( 4 ctx1abcd

343 "path", 

344 [ 

345 "/optional-list-bytes-alias-and-validation-alias", 

346 "/optional-list-uploadfile-alias-and-validation-alias", 

347 ], 

348) 

349def test_optional_list_alias_and_validation_alias_by_name(path: str): 4 ctx1abcd

350 client = TestClient(app) 3 ctx1DHL

351 response = client.post(path, files={"p": "hello"}) 3 ctx1DHL

352 assert response.status_code == 200 3 ctx1DHL

353 assert response.json() == {"file_size": None} 3 ctx1DHL

354 

355 

356@pytest.mark.parametrize( 4 ctx1abcd

357 "path", 

358 [ 

359 "/optional-list-bytes-alias-and-validation-alias", 

360 "/optional-list-uploadfile-alias-and-validation-alias", 

361 ], 

362) 

363def test_optional_list_alias_and_validation_alias_by_alias(path: str): 4 ctx1abcd

364 client = TestClient(app) 3 ctx1CGK

365 response = client.post(path, files=[("p_alias", b"hello"), ("p_alias", b"world")]) 3 ctx1CGK

366 assert response.status_code == 200, response.text 3 ctx1CGK

367 assert response.json() == {"file_size": None} 3 ctx1CGK

368 

369 

370@pytest.mark.parametrize( 4 ctx1abcd

371 "path", 

372 [ 

373 "/optional-list-bytes-alias-and-validation-alias", 

374 "/optional-list-uploadfile-alias-and-validation-alias", 

375 ], 

376) 

377def test_optional_list_alias_and_validation_alias_by_validation_alias(path: str): 4 ctx1abcd

378 client = TestClient(app) 3 ctx1EIM

379 response = client.post( 3 ctx1EIM

380 path, files=[("p_val_alias", b"hello"), ("p_val_alias", b"world")] 

381 ) 

382 assert response.status_code == 200, response.text 3 ctx1EIM

383 assert response.json() == {"file_size": [5, 5]} 3 ctx1EIM