Coverage for tests / test_path.py: 100%

1from fastapi.testclient import TestClient 4 ctx1abcd

2 

3from .main import app 4 ctx1abcd

4 

5client = TestClient(app) 4 ctx1abcd

6 

7 

8def test_text_get(): 4 ctx1abcd

9 response = client.get("/text") 3 ctx1efg

10 assert response.status_code == 200, response.text 3 ctx1efg

11 assert response.json() == "Hello World" 3 ctx1efg

12 

13 

14def test_nonexistent(): 4 ctx1abcd

15 response = client.get("/nonexistent") 3 ctx1hij

16 assert response.status_code == 404, response.text 3 ctx1hij

17 assert response.json() == {"detail": "Not Found"} 3 ctx1hij

18 

19 

20def test_path_foobar(): 4 ctx1abcd

21 response = client.get("/path/foobar") 3 ctx1klm

22 assert response.status_code == 200 3 ctx1klm

23 assert response.json() == "foobar" 3 ctx1klm

24 

25 

26def test_path_str_foobar(): 4 ctx1abcd

27 response = client.get("/path/str/foobar") 3 ctx1nop

28 assert response.status_code == 200 3 ctx1nop

29 assert response.json() == "foobar" 3 ctx1nop

30 

31 

32def test_path_str_42(): 4 ctx1abcd

33 response = client.get("/path/str/42") 3 ctx1qrs

34 assert response.status_code == 200 3 ctx1qrs

35 assert response.json() == "42" 3 ctx1qrs

36 

37 

38def test_path_str_True(): 4 ctx1abcd

39 response = client.get("/path/str/True") 3 ctx1tuv

40 assert response.status_code == 200 3 ctx1tuv

41 assert response.json() == "True" 3 ctx1tuv

42 

43 

44def test_path_int_foobar(): 4 ctx1abcd

45 response = client.get("/path/int/foobar") 3 ctx1wxy

46 assert response.status_code == 422 3 ctx1wxy

47 assert response.json() == { 3 ctx1wxy

48 "detail": [ 

49 { 

50 "type": "int_parsing", 

51 "loc": ["path", "item_id"], 

52 "msg": "Input should be a valid integer, unable to parse string as an integer", 

53 "input": "foobar", 

54 } 

55 ] 

56 } 

57 

58 

59def test_path_int_True(): 4 ctx1abcd

60 response = client.get("/path/int/True") 3 ctx1zAB

61 assert response.status_code == 422 3 ctx1zAB

62 assert response.json() == { 3 ctx1zAB

63 "detail": [ 

64 { 

65 "type": "int_parsing", 

66 "loc": ["path", "item_id"], 

67 "msg": "Input should be a valid integer, unable to parse string as an integer", 

68 "input": "True", 

69 } 

70 ] 

71 } 

72 

73 

74def test_path_int_42(): 4 ctx1abcd

75 response = client.get("/path/int/42") 3 ctx1CDE

76 assert response.status_code == 200 3 ctx1CDE

77 assert response.json() == 42 3 ctx1CDE

78 

79 

80def test_path_int_42_5(): 4 ctx1abcd

81 response = client.get("/path/int/42.5") 3 ctx1FGH

82 assert response.status_code == 422 3 ctx1FGH

83 assert response.json() == { 3 ctx1FGH

84 "detail": [ 

85 { 

86 "type": "int_parsing", 

87 "loc": ["path", "item_id"], 

88 "msg": "Input should be a valid integer, unable to parse string as an integer", 

89 "input": "42.5", 

90 } 

91 ] 

92 } 

93 

94 

95def test_path_float_foobar(): 4 ctx1abcd

96 response = client.get("/path/float/foobar") 3 ctx1IJK

97 assert response.status_code == 422 3 ctx1IJK

98 assert response.json() == { 3 ctx1IJK

99 "detail": [ 

100 { 

101 "type": "float_parsing", 

102 "loc": ["path", "item_id"], 

103 "msg": "Input should be a valid number, unable to parse string as a number", 

104 "input": "foobar", 

105 } 

106 ] 

107 } 

108 

109 

110def test_path_float_True(): 4 ctx1abcd

111 response = client.get("/path/float/True") 3 ctx1LMN

112 assert response.status_code == 422 3 ctx1LMN

113 assert response.json() == { 3 ctx1LMN

114 "detail": [ 

115 { 

116 "type": "float_parsing", 

117 "loc": ["path", "item_id"], 

118 "msg": "Input should be a valid number, unable to parse string as a number", 

119 "input": "True", 

120 } 

121 ] 

122 } 

123 

124 

125def test_path_float_42(): 4 ctx1abcd

126 response = client.get("/path/float/42") 3 ctx1OPQ

127 assert response.status_code == 200 3 ctx1OPQ

128 assert response.json() == 42 3 ctx1OPQ

129 

130 

131def test_path_float_42_5(): 4 ctx1abcd

132 response = client.get("/path/float/42.5") 3 ctx1RST

133 assert response.status_code == 200 3 ctx1RST

134 assert response.json() == 42.5 3 ctx1RST

135 

136 

137def test_path_bool_foobar(): 4 ctx1abcd

138 response = client.get("/path/bool/foobar") 3 ctx1UVW

139 assert response.status_code == 422 3 ctx1UVW

140 assert response.json() == { 3 ctx1UVW

141 "detail": [ 

142 { 

143 "type": "bool_parsing", 

144 "loc": ["path", "item_id"], 

145 "msg": "Input should be a valid boolean, unable to interpret input", 

146 "input": "foobar", 

147 } 

148 ] 

149 } 

150 

151 

152def test_path_bool_True(): 4 ctx1abcd

153 response = client.get("/path/bool/True") 3 ctx1XYZ

154 assert response.status_code == 200 3 ctx1XYZ

155 assert response.json() is True 3 ctx1XYZ

156 

157 

158def test_path_bool_42(): 4 ctx1abcd

159 response = client.get("/path/bool/42") 3 ctx1012

160 assert response.status_code == 422 3 ctx1012

161 assert response.json() == { 3 ctx1012

162 "detail": [ 

163 { 

164 "type": "bool_parsing", 

165 "loc": ["path", "item_id"], 

166 "msg": "Input should be a valid boolean, unable to interpret input", 

167 "input": "42", 

168 } 

169 ] 

170 } 

171 

172 

173def test_path_bool_42_5(): 4 ctx1abcd

174 response = client.get("/path/bool/42.5") 3 ctx1345

175 assert response.status_code == 422 3 ctx1345

176 assert response.json() == { 3 ctx1345

177 "detail": [ 

178 { 

179 "type": "bool_parsing", 

180 "loc": ["path", "item_id"], 

181 "msg": "Input should be a valid boolean, unable to interpret input", 

182 "input": "42.5", 

183 } 

184 ] 

185 } 

186 

187 

188def test_path_bool_1(): 4 ctx1abcd

189 response = client.get("/path/bool/1") 3 ctx1678

190 assert response.status_code == 200 3 ctx1678

191 assert response.json() is True 3 ctx1678

192 

193 

194def test_path_bool_0(): 4 ctx1abcd

195 response = client.get("/path/bool/0") 3 ctx19!#

196 assert response.status_code == 200 3 ctx19!#

197 assert response.json() is False 3 ctx19!#

198 

199 

200def test_path_bool_true(): 4 ctx1abcd

201 response = client.get("/path/bool/true") 3 ctx1$%'

202 assert response.status_code == 200 3 ctx1$%'

203 assert response.json() is True 3 ctx1$%'

204 

205 

206def test_path_bool_False(): 4 ctx1abcd

207 response = client.get("/path/bool/False") 3 ctx1()*

208 assert response.status_code == 200 3 ctx1()*

209 assert response.json() is False 3 ctx1()*

210 

211 

212def test_path_bool_false(): 4 ctx1abcd

213 response = client.get("/path/bool/false") 3 ctx1+,-

214 assert response.status_code == 200 3 ctx1+,-

215 assert response.json() is False 3 ctx1+,-

216 

217 

218def test_path_param_foo(): 4 ctx1abcd

219 response = client.get("/path/param/foo") 3 ctx1./:

220 assert response.status_code == 200 3 ctx1./:

221 assert response.json() == "foo" 3 ctx1./:

222 

223 

224def test_path_param_minlength_foo(): 4 ctx1abcd

225 response = client.get("/path/param-minlength/foo") 3 ctx1;=?

226 assert response.status_code == 200 3 ctx1;=?

227 assert response.json() == "foo" 3 ctx1;=?

228 

229 

230def test_path_param_minlength_fo(): 4 ctx1abcd

231 response = client.get("/path/param-minlength/fo") 3 ctx1@[]

232 assert response.status_code == 422 3 ctx1@[]

233 assert response.json() == { 3 ctx1@[]

234 "detail": [ 

235 { 

236 "type": "string_too_short", 

237 "loc": ["path", "item_id"], 

238 "msg": "String should have at least 3 characters", 

239 "input": "fo", 

240 "ctx": {"min_length": 3}, 

241 } 

242 ] 

243 } 

244 

245 

246def test_path_param_maxlength_foo(): 4 ctx1abcd

247 response = client.get("/path/param-maxlength/foo") 3 ctx1^_`

248 assert response.status_code == 200 3 ctx1^_`

249 assert response.json() == "foo" 3 ctx1^_`

250 

251 

252def test_path_param_maxlength_foobar(): 4 ctx1abcd

253 response = client.get("/path/param-maxlength/foobar") 3 ctx1{|}

254 assert response.status_code == 422 3 ctx1{|}

255 assert response.json() == { 3 ctx1{|}

256 "detail": [ 

257 { 

258 "type": "string_too_long", 

259 "loc": ["path", "item_id"], 

260 "msg": "String should have at most 3 characters", 

261 "input": "foobar", 

262 "ctx": {"max_length": 3}, 

263 } 

264 ] 

265 } 

266 

267 

268def test_path_param_min_maxlength_foo(): 4 ctx1abcd

269 response = client.get("/path/param-min_maxlength/foo") 3 ctx2~ abbb

270 assert response.status_code == 200 3 ctx2~ abbb

271 assert response.json() == "foo" 3 ctx2~ abbb

272 

273 

274def test_path_param_min_maxlength_foobar(): 4 ctx1abcd

275 response = client.get("/path/param-min_maxlength/foobar") 3 ctx2cbdbeb

276 assert response.status_code == 422 3 ctx2cbdbeb

277 assert response.json() == { 3 ctx2cbdbeb

278 "detail": [ 

279 { 

280 "type": "string_too_long", 

281 "loc": ["path", "item_id"], 

282 "msg": "String should have at most 3 characters", 

283 "input": "foobar", 

284 "ctx": {"max_length": 3}, 

285 } 

286 ] 

287 } 

288 

289 

290def test_path_param_min_maxlength_f(): 4 ctx1abcd

291 response = client.get("/path/param-min_maxlength/f") 3 ctx2fbgbhb

292 assert response.status_code == 422 3 ctx2fbgbhb

293 assert response.json() == { 3 ctx2fbgbhb

294 "detail": [ 

295 { 

296 "type": "string_too_short", 

297 "loc": ["path", "item_id"], 

298 "msg": "String should have at least 2 characters", 

299 "input": "f", 

300 "ctx": {"min_length": 2}, 

301 } 

302 ] 

303 } 

304 

305 

306def test_path_param_gt_42(): 4 ctx1abcd

307 response = client.get("/path/param-gt/42") 3 ctx2ibjbkb

308 assert response.status_code == 200 3 ctx2ibjbkb

309 assert response.json() == 42 3 ctx2ibjbkb

310 

311 

312def test_path_param_gt_2(): 4 ctx1abcd

313 response = client.get("/path/param-gt/2") 3 ctx2lbmbnb

314 assert response.status_code == 422 3 ctx2lbmbnb

315 assert response.json() == { 3 ctx2lbmbnb

316 "detail": [ 

317 { 

318 "type": "greater_than", 

319 "loc": ["path", "item_id"], 

320 "msg": "Input should be greater than 3", 

321 "input": "2", 

322 "ctx": {"gt": 3.0}, 

323 } 

324 ] 

325 } 

326 

327 

328def test_path_param_gt0_0_05(): 4 ctx1abcd

329 response = client.get("/path/param-gt0/0.05") 3 ctx2obpbqb

330 assert response.status_code == 200 3 ctx2obpbqb

331 assert response.json() == 0.05 3 ctx2obpbqb

332 

333 

334def test_path_param_gt0_0(): 4 ctx1abcd

335 response = client.get("/path/param-gt0/0") 3 ctx2rbsbtb

336 assert response.status_code == 422 3 ctx2rbsbtb

337 assert response.json() == { 3 ctx2rbsbtb

338 "detail": [ 

339 { 

340 "type": "greater_than", 

341 "loc": ["path", "item_id"], 

342 "msg": "Input should be greater than 0", 

343 "input": "0", 

344 "ctx": {"gt": 0.0}, 

345 } 

346 ] 

347 } 

348 

349 

350def test_path_param_ge_42(): 4 ctx1abcd

351 response = client.get("/path/param-ge/42") 3 ctx2ubvbwb

352 assert response.status_code == 200 3 ctx2ubvbwb

353 assert response.json() == 42 3 ctx2ubvbwb

354 

355 

356def test_path_param_ge_3(): 4 ctx1abcd

357 response = client.get("/path/param-ge/3") 3 ctx2xbybzb

358 assert response.status_code == 200 3 ctx2xbybzb

359 assert response.json() == 3 3 ctx2xbybzb

360 

361 

362def test_path_param_ge_2(): 4 ctx1abcd

363 response = client.get("/path/param-ge/2") 3 ctx2AbBbCb

364 assert response.status_code == 422 3 ctx2AbBbCb

365 assert response.json() == { 3 ctx2AbBbCb

366 "detail": [ 

367 { 

368 "type": "greater_than_equal", 

369 "loc": ["path", "item_id"], 

370 "msg": "Input should be greater than or equal to 3", 

371 "input": "2", 

372 "ctx": {"ge": 3.0}, 

373 } 

374 ] 

375 } 

376 

377 

378def test_path_param_lt_42(): 4 ctx1abcd

379 response = client.get("/path/param-lt/42") 3 ctx2DbEbFb

380 assert response.status_code == 422 3 ctx2DbEbFb

381 assert response.json() == { 3 ctx2DbEbFb

382 "detail": [ 

383 { 

384 "type": "less_than", 

385 "loc": ["path", "item_id"], 

386 "msg": "Input should be less than 3", 

387 "input": "42", 

388 "ctx": {"lt": 3.0}, 

389 } 

390 ] 

391 } 

392 

393 

394def test_path_param_lt_2(): 4 ctx1abcd

395 response = client.get("/path/param-lt/2") 3 ctx2GbHbIb

396 assert response.status_code == 200 3 ctx2GbHbIb

397 assert response.json() == 2 3 ctx2GbHbIb

398 

399 

400def test_path_param_lt0__1(): 4 ctx1abcd

401 response = client.get("/path/param-lt0/-1") 3 ctx2JbKbLb

402 assert response.status_code == 200 3 ctx2JbKbLb

403 assert response.json() == -1 3 ctx2JbKbLb

404 

405 

406def test_path_param_lt0_0(): 4 ctx1abcd

407 response = client.get("/path/param-lt0/0") 3 ctx2MbNbOb

408 assert response.status_code == 422 3 ctx2MbNbOb

409 assert response.json() == { 3 ctx2MbNbOb

410 "detail": [ 

411 { 

412 "type": "less_than", 

413 "loc": ["path", "item_id"], 

414 "msg": "Input should be less than 0", 

415 "input": "0", 

416 "ctx": {"lt": 0.0}, 

417 } 

418 ] 

419 } 

420 

421 

422def test_path_param_le_42(): 4 ctx1abcd

423 response = client.get("/path/param-le/42") 3 ctx2PbQbRb

424 assert response.status_code == 422 3 ctx2PbQbRb

425 assert response.json() == { 3 ctx2PbQbRb

426 "detail": [ 

427 { 

428 "type": "less_than_equal", 

429 "loc": ["path", "item_id"], 

430 "msg": "Input should be less than or equal to 3", 

431 "input": "42", 

432 "ctx": {"le": 3.0}, 

433 } 

434 ] 

435 } 

436 

437 

438def test_path_param_le_3(): 4 ctx1abcd

439 response = client.get("/path/param-le/3") 3 ctx2SbTbUb

440 assert response.status_code == 200 3 ctx2SbTbUb

441 assert response.json() == 3 3 ctx2SbTbUb

442 

443 

444def test_path_param_le_2(): 4 ctx1abcd

445 response = client.get("/path/param-le/2") 3 ctx2VbWbXb

446 assert response.status_code == 200 3 ctx2VbWbXb

447 assert response.json() == 2 3 ctx2VbWbXb

448 

449 

450def test_path_param_lt_gt_2(): 4 ctx1abcd

451 response = client.get("/path/param-lt-gt/2") 3 ctx2YbZb0b

452 assert response.status_code == 200 3 ctx2YbZb0b

453 assert response.json() == 2 3 ctx2YbZb0b

454 

455 

456def test_path_param_lt_gt_4(): 4 ctx1abcd

457 response = client.get("/path/param-lt-gt/4") 3 ctx21b2b3b

458 assert response.status_code == 422 3 ctx21b2b3b

459 assert response.json() == { 3 ctx21b2b3b

460 "detail": [ 

461 { 

462 "type": "less_than", 

463 "loc": ["path", "item_id"], 

464 "msg": "Input should be less than 3", 

465 "input": "4", 

466 "ctx": {"lt": 3.0}, 

467 } 

468 ] 

469 } 

470 

471 

472def test_path_param_lt_gt_0(): 4 ctx1abcd

473 response = client.get("/path/param-lt-gt/0") 3 ctx24b5b6b

474 assert response.status_code == 422 3 ctx24b5b6b

475 assert response.json() == { 3 ctx24b5b6b

476 "detail": [ 

477 { 

478 "type": "greater_than", 

479 "loc": ["path", "item_id"], 

480 "msg": "Input should be greater than 1", 

481 "input": "0", 

482 "ctx": {"gt": 1.0}, 

483 } 

484 ] 

485 } 

486 

487 

488def test_path_param_le_ge_2(): 4 ctx1abcd

489 response = client.get("/path/param-le-ge/2") 3 ctx27b8b9b

490 assert response.status_code == 200 3 ctx27b8b9b

491 assert response.json() == 2 3 ctx27b8b9b

492 

493 

494def test_path_param_le_ge_1(): 4 ctx1abcd

495 response = client.get("/path/param-le-ge/1") 3 ctx2WcXcYc

496 assert response.status_code == 200 3 ctx2WcXcYc

497 

498 

499def test_path_param_le_ge_3(): 4 ctx1abcd

500 response = client.get("/path/param-le-ge/3") 3 ctx2!b#b$b

501 assert response.status_code == 200 3 ctx2!b#b$b

502 assert response.json() == 3 3 ctx2!b#b$b

503 

504 

505def test_path_param_le_ge_4(): 4 ctx1abcd

506 response = client.get("/path/param-le-ge/4") 3 ctx2%b'b(b

507 assert response.status_code == 422 3 ctx2%b'b(b

508 assert response.json() == { 3 ctx2%b'b(b

509 "detail": [ 

510 { 

511 "type": "less_than_equal", 

512 "loc": ["path", "item_id"], 

513 "msg": "Input should be less than or equal to 3", 

514 "input": "4", 

515 "ctx": {"le": 3.0}, 

516 } 

517 ] 

518 } 

519 

520 

521def test_path_param_lt_int_2(): 4 ctx1abcd

522 response = client.get("/path/param-lt-int/2") 3 ctx2)b*b+b

523 assert response.status_code == 200 3 ctx2)b*b+b

524 assert response.json() == 2 3 ctx2)b*b+b

525 

526 

527def test_path_param_lt_int_42(): 4 ctx1abcd

528 response = client.get("/path/param-lt-int/42") 3 ctx2,b-b.b

529 assert response.status_code == 422 3 ctx2,b-b.b

530 assert response.json() == { 3 ctx2,b-b.b

531 "detail": [ 

532 { 

533 "type": "less_than", 

534 "loc": ["path", "item_id"], 

535 "msg": "Input should be less than 3", 

536 "input": "42", 

537 "ctx": {"lt": 3}, 

538 } 

539 ] 

540 } 

541 

542 

543def test_path_param_lt_int_2_7(): 4 ctx1abcd

544 response = client.get("/path/param-lt-int/2.7") 3 ctx2/b:b;b

545 assert response.status_code == 422 3 ctx2/b:b;b

546 assert response.json() == { 3 ctx2/b:b;b

547 "detail": [ 

548 { 

549 "type": "int_parsing", 

550 "loc": ["path", "item_id"], 

551 "msg": "Input should be a valid integer, unable to parse string as an integer", 

552 "input": "2.7", 

553 } 

554 ] 

555 } 

556 

557 

558def test_path_param_gt_int_42(): 4 ctx1abcd

559 response = client.get("/path/param-gt-int/42") 3 ctx2=b?b@b

560 assert response.status_code == 200 3 ctx2=b?b@b

561 assert response.json() == 42 3 ctx2=b?b@b

562 

563 

564def test_path_param_gt_int_2(): 4 ctx1abcd

565 response = client.get("/path/param-gt-int/2") 3 ctx2[b]b^b

566 assert response.status_code == 422 3 ctx2[b]b^b

567 assert response.json() == { 3 ctx2[b]b^b

568 "detail": [ 

569 { 

570 "type": "greater_than", 

571 "loc": ["path", "item_id"], 

572 "msg": "Input should be greater than 3", 

573 "input": "2", 

574 "ctx": {"gt": 3}, 

575 } 

576 ] 

577 } 

578 

579 

580def test_path_param_gt_int_2_7(): 4 ctx1abcd

581 response = client.get("/path/param-gt-int/2.7") 3 ctx2_b`b{b

582 assert response.status_code == 422 3 ctx2_b`b{b

583 assert response.json() == { 3 ctx2_b`b{b

584 "detail": [ 

585 { 

586 "type": "int_parsing", 

587 "loc": ["path", "item_id"], 

588 "msg": "Input should be a valid integer, unable to parse string as an integer", 

589 "input": "2.7", 

590 } 

591 ] 

592 } 

593 

594 

595def test_path_param_le_int_42(): 4 ctx1abcd

596 response = client.get("/path/param-le-int/42") 3 ctx2|b}b~b

597 assert response.status_code == 422 3 ctx2|b}b~b

598 assert response.json() == { 3 ctx2|b}b~b

599 "detail": [ 

600 { 

601 "type": "less_than_equal", 

602 "loc": ["path", "item_id"], 

603 "msg": "Input should be less than or equal to 3", 

604 "input": "42", 

605 "ctx": {"le": 3}, 

606 } 

607 ] 

608 } 

609 

610 

611def test_path_param_le_int_3(): 4 ctx1abcd

612 response = client.get("/path/param-le-int/3") 3 ctx2acbccc

613 assert response.status_code == 200 3 ctx2acbccc

614 assert response.json() == 3 3 ctx2acbccc

615 

616 

617def test_path_param_le_int_2(): 4 ctx1abcd

618 response = client.get("/path/param-le-int/2") 3 ctx2dcecfc

619 assert response.status_code == 200 3 ctx2dcecfc

620 assert response.json() == 2 3 ctx2dcecfc

621 

622 

623def test_path_param_le_int_2_7(): 4 ctx1abcd

624 response = client.get("/path/param-le-int/2.7") 3 ctx2gchcic

625 assert response.status_code == 422 3 ctx2gchcic

626 assert response.json() == { 3 ctx2gchcic

627 "detail": [ 

628 { 

629 "type": "int_parsing", 

630 "loc": ["path", "item_id"], 

631 "msg": "Input should be a valid integer, unable to parse string as an integer", 

632 "input": "2.7", 

633 } 

634 ] 

635 } 

636 

637 

638def test_path_param_ge_int_42(): 4 ctx1abcd

639 response = client.get("/path/param-ge-int/42") 3 ctx2jckclc

640 assert response.status_code == 200 3 ctx2jckclc

641 assert response.json() == 42 3 ctx2jckclc

642 

643 

644def test_path_param_ge_int_3(): 4 ctx1abcd

645 response = client.get("/path/param-ge-int/3") 3 ctx2mcncoc

646 assert response.status_code == 200 3 ctx2mcncoc

647 assert response.json() == 3 3 ctx2mcncoc

648 

649 

650def test_path_param_ge_int_2(): 4 ctx1abcd

651 response = client.get("/path/param-ge-int/2") 3 ctx2pcqcrc

652 assert response.status_code == 422 3 ctx2pcqcrc

653 assert response.json() == { 3 ctx2pcqcrc

654 "detail": [ 

655 { 

656 "type": "greater_than_equal", 

657 "loc": ["path", "item_id"], 

658 "msg": "Input should be greater than or equal to 3", 

659 "input": "2", 

660 "ctx": {"ge": 3}, 

661 } 

662 ] 

663 } 

664 

665 

666def test_path_param_ge_int_2_7(): 4 ctx1abcd

667 response = client.get("/path/param-ge-int/2.7") 3 ctx2sctcuc

668 assert response.status_code == 422 3 ctx2sctcuc

669 assert response.json() == { 3 ctx2sctcuc

670 "detail": [ 

671 { 

672 "type": "int_parsing", 

673 "loc": ["path", "item_id"], 

674 "msg": "Input should be a valid integer, unable to parse string as an integer", 

675 "input": "2.7", 

676 } 

677 ] 

678 } 

679 

680 

681def test_path_param_lt_gt_int_2(): 4 ctx1abcd

682 response = client.get("/path/param-lt-gt-int/2") 3 ctx2vcwcxc

683 assert response.status_code == 200 3 ctx2vcwcxc

684 assert response.json() == 2 3 ctx2vcwcxc

685 

686 

687def test_path_param_lt_gt_int_4(): 4 ctx1abcd

688 response = client.get("/path/param-lt-gt-int/4") 3 ctx2yczcAc

689 assert response.status_code == 422 3 ctx2yczcAc

690 assert response.json() == { 3 ctx2yczcAc

691 "detail": [ 

692 { 

693 "type": "less_than", 

694 "loc": ["path", "item_id"], 

695 "msg": "Input should be less than 3", 

696 "input": "4", 

697 "ctx": {"lt": 3}, 

698 } 

699 ] 

700 } 

701 

702 

703def test_path_param_lt_gt_int_0(): 4 ctx1abcd

704 response = client.get("/path/param-lt-gt-int/0") 3 ctx2BcCcDc

705 assert response.status_code == 422 3 ctx2BcCcDc

706 assert response.json() == { 3 ctx2BcCcDc

707 "detail": [ 

708 { 

709 "type": "greater_than", 

710 "loc": ["path", "item_id"], 

711 "msg": "Input should be greater than 1", 

712 "input": "0", 

713 "ctx": {"gt": 1}, 

714 } 

715 ] 

716 } 

717 

718 

719def test_path_param_lt_gt_int_2_7(): 4 ctx1abcd

720 response = client.get("/path/param-lt-gt-int/2.7") 3 ctx2EcFcGc

721 assert response.status_code == 422 3 ctx2EcFcGc

722 assert response.json() == { 3 ctx2EcFcGc

723 "detail": [ 

724 { 

725 "type": "int_parsing", 

726 "loc": ["path", "item_id"], 

727 "msg": "Input should be a valid integer, unable to parse string as an integer", 

728 "input": "2.7", 

729 } 

730 ] 

731 } 

732 

733 

734def test_path_param_le_ge_int_2(): 4 ctx1abcd

735 response = client.get("/path/param-le-ge-int/2") 3 ctx2HcIcJc

736 assert response.status_code == 200 3 ctx2HcIcJc

737 assert response.json() == 2 3 ctx2HcIcJc

738 

739 

740def test_path_param_le_ge_int_1(): 4 ctx1abcd

741 response = client.get("/path/param-le-ge-int/1") 3 ctx2KcLcMc

742 assert response.status_code == 200 3 ctx2KcLcMc

743 assert response.json() == 1 3 ctx2KcLcMc

744 

745 

746def test_path_param_le_ge_int_3(): 4 ctx1abcd

747 response = client.get("/path/param-le-ge-int/3") 3 ctx2NcOcPc

748 assert response.status_code == 200 3 ctx2NcOcPc

749 assert response.json() == 3 3 ctx2NcOcPc

750 

751 

752def test_path_param_le_ge_int_4(): 4 ctx1abcd

753 response = client.get("/path/param-le-ge-int/4") 3 ctx2QcRcSc

754 assert response.status_code == 422 3 ctx2QcRcSc

755 assert response.json() == { 3 ctx2QcRcSc

756 "detail": [ 

757 { 

758 "type": "less_than_equal", 

759 "loc": ["path", "item_id"], 

760 "msg": "Input should be less than or equal to 3", 

761 "input": "4", 

762 "ctx": {"le": 3}, 

763 } 

764 ] 

765 } 

766 

767 

768def test_path_param_le_ge_int_2_7(): 4 ctx1abcd

769 response = client.get("/path/param-le-ge-int/2.7") 3 ctx2TcUcVc

770 assert response.status_code == 422 3 ctx2TcUcVc

771 assert response.json() == { 3 ctx2TcUcVc

772 "detail": [ 

773 { 

774 "type": "int_parsing", 

775 "loc": ["path", "item_id"], 

776 "msg": "Input should be a valid integer, unable to parse string as an integer", 

777 "input": "2.7", 

778 } 

779 ] 

780 }