Coverage for tests/test_path.py: 100%

1from dirty_equals import IsDict 5 ctx1abcde

2from fastapi.testclient import TestClient 5 ctx1abcde

3 

4from .main import app 5 ctx1abcde

5 

6client = TestClient(app) 5 ctx1abcde

7 

8 

9def test_text_get(): 5 ctx1abcde

10 response = client.get("/text") 5 ctx1fghij

11 assert response.status_code == 200, response.text 5 ctx1fghij

12 assert response.json() == "Hello World" 5 ctx1fghij

13 

14 

15def test_nonexistent(): 5 ctx1abcde

16 response = client.get("/nonexistent") 5 ctx1klmno

17 assert response.status_code == 404, response.text 5 ctx1klmno

18 assert response.json() == {"detail": "Not Found"} 5 ctx1klmno

19 

20 

21def test_path_foobar(): 5 ctx1abcde

22 response = client.get("/path/foobar") 5 ctx1pqrst

23 assert response.status_code == 200 5 ctx1pqrst

24 assert response.json() == "foobar" 5 ctx1pqrst

25 

26 

27def test_path_str_foobar(): 5 ctx1abcde

28 response = client.get("/path/str/foobar") 5 ctx1uvwxy

29 assert response.status_code == 200 5 ctx1uvwxy

30 assert response.json() == "foobar" 5 ctx1uvwxy

31 

32 

33def test_path_str_42(): 5 ctx1abcde

34 response = client.get("/path/str/42") 5 ctx1zABCD

35 assert response.status_code == 200 5 ctx1zABCD

36 assert response.json() == "42" 5 ctx1zABCD

37 

38 

39def test_path_str_True(): 5 ctx1abcde

40 response = client.get("/path/str/True") 5 ctx1EFGHI

41 assert response.status_code == 200 5 ctx1EFGHI

42 assert response.json() == "True" 5 ctx1EFGHI

43 

44 

45def test_path_int_foobar(): 5 ctx1abcde

46 response = client.get("/path/int/foobar") 5 ctx1JKLMN

47 assert response.status_code == 422 5 ctx1JKLMN

48 assert response.json() == IsDict( 5 ctx1JKLMN

49 { 

50 "detail": [ 

51 { 

52 "type": "int_parsing", 

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

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

55 "input": "foobar", 

56 } 

57 ] 

58 } 

59 ) | IsDict( 

60 # TODO: remove when deprecating Pydantic v1 

61 { 

62 "detail": [ 

63 { 

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

65 "msg": "value is not a valid integer", 

66 "type": "type_error.integer", 

67 } 

68 ] 

69 } 

70 ) 

71 

72 

73def test_path_int_True(): 5 ctx1abcde

74 response = client.get("/path/int/True") 5 ctx1OPQRS

75 assert response.status_code == 422 5 ctx1OPQRS

76 assert response.json() == IsDict( 5 ctx1OPQRS

77 { 

78 "detail": [ 

79 { 

80 "type": "int_parsing", 

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

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

83 "input": "True", 

84 } 

85 ] 

86 } 

87 ) | IsDict( 

88 # TODO: remove when deprecating Pydantic v1 

89 { 

90 "detail": [ 

91 { 

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

93 "msg": "value is not a valid integer", 

94 "type": "type_error.integer", 

95 } 

96 ] 

97 } 

98 ) 

99 

100 

101def test_path_int_42(): 5 ctx1abcde

102 response = client.get("/path/int/42") 5 ctx1TUVWX

103 assert response.status_code == 200 5 ctx1TUVWX

104 assert response.json() == 42 5 ctx1TUVWX

105 

106 

107def test_path_int_42_5(): 5 ctx1abcde

108 response = client.get("/path/int/42.5") 5 ctx1YZ012

109 assert response.status_code == 422 5 ctx1YZ012

110 assert response.json() == IsDict( 5 ctx1YZ012

111 { 

112 "detail": [ 

113 { 

114 "type": "int_parsing", 

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

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

117 "input": "42.5", 

118 } 

119 ] 

120 } 

121 ) | IsDict( 

122 # TODO: remove when deprecating Pydantic v1 

123 { 

124 "detail": [ 

125 { 

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

127 "msg": "value is not a valid integer", 

128 "type": "type_error.integer", 

129 } 

130 ] 

131 } 

132 ) 

133 

134 

135def test_path_float_foobar(): 5 ctx1abcde

136 response = client.get("/path/float/foobar") 5 ctx134567

137 assert response.status_code == 422 5 ctx134567

138 assert response.json() == IsDict( 5 ctx134567

139 { 

140 "detail": [ 

141 { 

142 "type": "float_parsing", 

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

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

145 "input": "foobar", 

146 } 

147 ] 

148 } 

149 ) | IsDict( 

150 # TODO: remove when deprecating Pydantic v1 

151 { 

152 "detail": [ 

153 { 

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

155 "msg": "value is not a valid float", 

156 "type": "type_error.float", 

157 } 

158 ] 

159 } 

160 ) 

161 

162 

163def test_path_float_True(): 5 ctx1abcde

164 response = client.get("/path/float/True") 5 ctx189!#$

165 assert response.status_code == 422 5 ctx189!#$

166 assert response.json() == IsDict( 5 ctx189!#$

167 { 

168 "detail": [ 

169 { 

170 "type": "float_parsing", 

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

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

173 "input": "True", 

174 } 

175 ] 

176 } 

177 ) | IsDict( 

178 # TODO: remove when deprecating Pydantic v1 

179 { 

180 "detail": [ 

181 { 

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

183 "msg": "value is not a valid float", 

184 "type": "type_error.float", 

185 } 

186 ] 

187 } 

188 ) 

189 

190 

191def test_path_float_42(): 5 ctx1abcde

192 response = client.get("/path/float/42") 5 ctx1%'()*

193 assert response.status_code == 200 5 ctx1%'()*

194 assert response.json() == 42 5 ctx1%'()*

195 

196 

197def test_path_float_42_5(): 5 ctx1abcde

198 response = client.get("/path/float/42.5") 5 ctx1+,-./

199 assert response.status_code == 200 5 ctx1+,-./

200 assert response.json() == 42.5 5 ctx1+,-./

201 

202 

203def test_path_bool_foobar(): 5 ctx1abcde

204 response = client.get("/path/bool/foobar") 5 ctx1:;=?@

205 assert response.status_code == 422 5 ctx1:;=?@

206 assert response.json() == IsDict( 5 ctx1:;=?@

207 { 

208 "detail": [ 

209 { 

210 "type": "bool_parsing", 

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

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

213 "input": "foobar", 

214 } 

215 ] 

216 } 

217 ) | IsDict( 

218 # TODO: remove when deprecating Pydantic v1 

219 { 

220 "detail": [ 

221 { 

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

223 "msg": "value could not be parsed to a boolean", 

224 "type": "type_error.bool", 

225 } 

226 ] 

227 } 

228 ) 

229 

230 

231def test_path_bool_True(): 5 ctx1abcde

232 response = client.get("/path/bool/True") 5 ctx1[]^_`

233 assert response.status_code == 200 5 ctx1[]^_`

234 assert response.json() is True 5 ctx1[]^_`

235 

236 

237def test_path_bool_42(): 5 ctx1abcde

238 response = client.get("/path/bool/42") 5 ctx2{ | } ~ ab

239 assert response.status_code == 422 5 ctx2{ | } ~ ab

240 assert response.json() == IsDict( 5 ctx2{ | } ~ ab

241 { 

242 "detail": [ 

243 { 

244 "type": "bool_parsing", 

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

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

247 "input": "42", 

248 } 

249 ] 

250 } 

251 ) | IsDict( 

252 # TODO: remove when deprecating Pydantic v1 

253 { 

254 "detail": [ 

255 { 

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

257 "msg": "value could not be parsed to a boolean", 

258 "type": "type_error.bool", 

259 } 

260 ] 

261 } 

262 ) 

263 

264 

265def test_path_bool_42_5(): 5 ctx1abcde

266 response = client.get("/path/bool/42.5") 5 ctx2bbcbdbebfb

267 assert response.status_code == 422 5 ctx2bbcbdbebfb

268 assert response.json() == IsDict( 5 ctx2bbcbdbebfb

269 { 

270 "detail": [ 

271 { 

272 "type": "bool_parsing", 

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

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

275 "input": "42.5", 

276 } 

277 ] 

278 } 

279 ) | IsDict( 

280 # TODO: remove when deprecating Pydantic v1 

281 { 

282 "detail": [ 

283 { 

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

285 "msg": "value could not be parsed to a boolean", 

286 "type": "type_error.bool", 

287 } 

288 ] 

289 } 

290 ) 

291 

292 

293def test_path_bool_1(): 5 ctx1abcde

294 response = client.get("/path/bool/1") 5 ctx2gbhbibjbkb

295 assert response.status_code == 200 5 ctx2gbhbibjbkb

296 assert response.json() is True 5 ctx2gbhbibjbkb

297 

298 

299def test_path_bool_0(): 5 ctx1abcde

300 response = client.get("/path/bool/0") 5 ctx2lbmbnbobpb

301 assert response.status_code == 200 5 ctx2lbmbnbobpb

302 assert response.json() is False 5 ctx2lbmbnbobpb

303 

304 

305def test_path_bool_true(): 5 ctx1abcde

306 response = client.get("/path/bool/true") 5 ctx2qbrbsbtbub

307 assert response.status_code == 200 5 ctx2qbrbsbtbub

308 assert response.json() is True 5 ctx2qbrbsbtbub

309 

310 

311def test_path_bool_False(): 5 ctx1abcde

312 response = client.get("/path/bool/False") 5 ctx2vbwbxbybzb

313 assert response.status_code == 200 5 ctx2vbwbxbybzb

314 assert response.json() is False 5 ctx2vbwbxbybzb

315 

316 

317def test_path_bool_false(): 5 ctx1abcde

318 response = client.get("/path/bool/false") 5 ctx2AbBbCbDbEb

319 assert response.status_code == 200 5 ctx2AbBbCbDbEb

320 assert response.json() is False 5 ctx2AbBbCbDbEb

321 

322 

323def test_path_param_foo(): 5 ctx1abcde

324 response = client.get("/path/param/foo") 5 ctx2FbGbHbIbJb

325 assert response.status_code == 200 5 ctx2FbGbHbIbJb

326 assert response.json() == "foo" 5 ctx2FbGbHbIbJb

327 

328 

329def test_path_param_minlength_foo(): 5 ctx1abcde

330 response = client.get("/path/param-minlength/foo") 5 ctx2KbLbMbNbOb

331 assert response.status_code == 200 5 ctx2KbLbMbNbOb

332 assert response.json() == "foo" 5 ctx2KbLbMbNbOb

333 

334 

335def test_path_param_minlength_fo(): 5 ctx1abcde

336 response = client.get("/path/param-minlength/fo") 5 ctx2PbQbRbSbTb

337 assert response.status_code == 422 5 ctx2PbQbRbSbTb

338 assert response.json() == IsDict( 5 ctx2PbQbRbSbTb

339 { 

340 "detail": [ 

341 { 

342 "type": "string_too_short", 

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

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

345 "input": "fo", 

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

347 } 

348 ] 

349 } 

350 ) | IsDict( 

351 # TODO: remove when deprecating Pydantic v1 

352 { 

353 "detail": [ 

354 { 

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

356 "msg": "ensure this value has at least 3 characters", 

357 "type": "value_error.any_str.min_length", 

358 "ctx": {"limit_value": 3}, 

359 } 

360 ] 

361 } 

362 ) 

363 

364 

365def test_path_param_maxlength_foo(): 5 ctx1abcde

366 response = client.get("/path/param-maxlength/foo") 5 ctx2UbVbWbXbYb

367 assert response.status_code == 200 5 ctx2UbVbWbXbYb

368 assert response.json() == "foo" 5 ctx2UbVbWbXbYb

369 

370 

371def test_path_param_maxlength_foobar(): 5 ctx1abcde

372 response = client.get("/path/param-maxlength/foobar") 5 ctx2Zb0b1b2b3b

373 assert response.status_code == 422 5 ctx2Zb0b1b2b3b

374 assert response.json() == IsDict( 5 ctx2Zb0b1b2b3b

375 { 

376 "detail": [ 

377 { 

378 "type": "string_too_long", 

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

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

381 "input": "foobar", 

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

383 } 

384 ] 

385 } 

386 ) | IsDict( 

387 # TODO: remove when deprecating Pydantic v1 

388 { 

389 "detail": [ 

390 { 

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

392 "msg": "ensure this value has at most 3 characters", 

393 "type": "value_error.any_str.max_length", 

394 "ctx": {"limit_value": 3}, 

395 } 

396 ] 

397 } 

398 ) 

399 

400 

401def test_path_param_min_maxlength_foo(): 5 ctx1abcde

402 response = client.get("/path/param-min_maxlength/foo") 5 ctx24b5b6b7b8b

403 assert response.status_code == 200 5 ctx24b5b6b7b8b

404 assert response.json() == "foo" 5 ctx24b5b6b7b8b

405 

406 

407def test_path_param_min_maxlength_foobar(): 5 ctx1abcde

408 response = client.get("/path/param-min_maxlength/foobar") 5 ctx29b!b#b$b%b

409 assert response.status_code == 422 5 ctx29b!b#b$b%b

410 assert response.json() == IsDict( 5 ctx29b!b#b$b%b

411 { 

412 "detail": [ 

413 { 

414 "type": "string_too_long", 

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

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

417 "input": "foobar", 

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

419 } 

420 ] 

421 } 

422 ) | IsDict( 

423 # TODO: remove when deprecating Pydantic v1 

424 { 

425 "detail": [ 

426 { 

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

428 "msg": "ensure this value has at most 3 characters", 

429 "type": "value_error.any_str.max_length", 

430 "ctx": {"limit_value": 3}, 

431 } 

432 ] 

433 } 

434 ) 

435 

436 

437def test_path_param_min_maxlength_f(): 5 ctx1abcde

438 response = client.get("/path/param-min_maxlength/f") 5 ctx2'b(b)b*b+b

439 assert response.status_code == 422 5 ctx2'b(b)b*b+b

440 assert response.json() == IsDict( 5 ctx2'b(b)b*b+b

441 { 

442 "detail": [ 

443 { 

444 "type": "string_too_short", 

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

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

447 "input": "f", 

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

449 } 

450 ] 

451 } 

452 ) | IsDict( 

453 { 

454 "detail": [ 

455 { 

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

457 "msg": "ensure this value has at least 2 characters", 

458 "type": "value_error.any_str.min_length", 

459 "ctx": {"limit_value": 2}, 

460 } 

461 ] 

462 } 

463 ) 

464 

465 

466def test_path_param_gt_42(): 5 ctx1abcde

467 response = client.get("/path/param-gt/42") 5 ctx2,b-b.b/b:b

468 assert response.status_code == 200 5 ctx2,b-b.b/b:b

469 assert response.json() == 42 5 ctx2,b-b.b/b:b

470 

471 

472def test_path_param_gt_2(): 5 ctx1abcde

473 response = client.get("/path/param-gt/2") 5 ctx2;b=b?b@b[b

474 assert response.status_code == 422 5 ctx2;b=b?b@b[b

475 assert response.json() == IsDict( 5 ctx2;b=b?b@b[b

476 { 

477 "detail": [ 

478 { 

479 "type": "greater_than", 

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

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

482 "input": "2", 

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

484 } 

485 ] 

486 } 

487 ) | IsDict( 

488 # TODO: remove when deprecating Pydantic v1 

489 { 

490 "detail": [ 

491 { 

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

493 "msg": "ensure this value is greater than 3", 

494 "type": "value_error.number.not_gt", 

495 "ctx": {"limit_value": 3}, 

496 } 

497 ] 

498 } 

499 ) 

500 

501 

502def test_path_param_gt0_0_05(): 5 ctx1abcde

503 response = client.get("/path/param-gt0/0.05") 5 ctx2]b^b_b`b{b

504 assert response.status_code == 200 5 ctx2]b^b_b`b{b

505 assert response.json() == 0.05 5 ctx2]b^b_b`b{b

506 

507 

508def test_path_param_gt0_0(): 5 ctx1abcde

509 response = client.get("/path/param-gt0/0") 5 ctx2|b}b~bacbc

510 assert response.status_code == 422 5 ctx2|b}b~bacbc

511 assert response.json() == IsDict( 5 ctx2|b}b~bacbc

512 { 

513 "detail": [ 

514 { 

515 "type": "greater_than", 

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

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

518 "input": "0", 

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

520 } 

521 ] 

522 } 

523 ) | IsDict( 

524 # TODO: remove when deprecating Pydantic v1 

525 { 

526 "detail": [ 

527 { 

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

529 "msg": "ensure this value is greater than 0", 

530 "type": "value_error.number.not_gt", 

531 "ctx": {"limit_value": 0}, 

532 } 

533 ] 

534 } 

535 ) 

536 

537 

538def test_path_param_ge_42(): 5 ctx1abcde

539 response = client.get("/path/param-ge/42") 5 ctx2ccdcecfcgc

540 assert response.status_code == 200 5 ctx2ccdcecfcgc

541 assert response.json() == 42 5 ctx2ccdcecfcgc

542 

543 

544def test_path_param_ge_3(): 5 ctx1abcde

545 response = client.get("/path/param-ge/3") 5 ctx2hcicjckclc

546 assert response.status_code == 200 5 ctx2hcicjckclc

547 assert response.json() == 3 5 ctx2hcicjckclc

548 

549 

550def test_path_param_ge_2(): 5 ctx1abcde

551 response = client.get("/path/param-ge/2") 5 ctx2mcncocpcqc

552 assert response.status_code == 422 5 ctx2mcncocpcqc

553 assert response.json() == IsDict( 5 ctx2mcncocpcqc

554 { 

555 "detail": [ 

556 { 

557 "type": "greater_than_equal", 

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

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

560 "input": "2", 

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

562 } 

563 ] 

564 } 

565 ) | IsDict( 

566 # TODO: remove when deprecating Pydantic v1 

567 { 

568 "detail": [ 

569 { 

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

571 "msg": "ensure this value is greater than or equal to 3", 

572 "type": "value_error.number.not_ge", 

573 "ctx": {"limit_value": 3}, 

574 } 

575 ] 

576 } 

577 ) 

578 

579 

580def test_path_param_lt_42(): 5 ctx1abcde

581 response = client.get("/path/param-lt/42") 5 ctx2rcsctcucvc

582 assert response.status_code == 422 5 ctx2rcsctcucvc

583 assert response.json() == IsDict( 5 ctx2rcsctcucvc

584 { 

585 "detail": [ 

586 { 

587 "type": "less_than", 

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

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

590 "input": "42", 

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

592 } 

593 ] 

594 } 

595 ) | IsDict( 

596 # TODO: remove when deprecating Pydantic v1 

597 { 

598 "detail": [ 

599 { 

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

601 "msg": "ensure this value is less than 3", 

602 "type": "value_error.number.not_lt", 

603 "ctx": {"limit_value": 3}, 

604 } 

605 ] 

606 } 

607 ) 

608 

609 

610def test_path_param_lt_2(): 5 ctx1abcde

611 response = client.get("/path/param-lt/2") 5 ctx2wcxcyczcAc

612 assert response.status_code == 200 5 ctx2wcxcyczcAc

613 assert response.json() == 2 5 ctx2wcxcyczcAc

614 

615 

616def test_path_param_lt0__1(): 5 ctx1abcde

617 response = client.get("/path/param-lt0/-1") 5 ctx2BcCcDcEcFc

618 assert response.status_code == 200 5 ctx2BcCcDcEcFc

619 assert response.json() == -1 5 ctx2BcCcDcEcFc

620 

621 

622def test_path_param_lt0_0(): 5 ctx1abcde

623 response = client.get("/path/param-lt0/0") 5 ctx2GcHcIcJcKc

624 assert response.status_code == 422 5 ctx2GcHcIcJcKc

625 assert response.json() == IsDict( 5 ctx2GcHcIcJcKc

626 { 

627 "detail": [ 

628 { 

629 "type": "less_than", 

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

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

632 "input": "0", 

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

634 } 

635 ] 

636 } 

637 ) | IsDict( 

638 # TODO: remove when deprecating Pydantic v1 

639 { 

640 "detail": [ 

641 { 

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

643 "msg": "ensure this value is less than 0", 

644 "type": "value_error.number.not_lt", 

645 "ctx": {"limit_value": 0}, 

646 } 

647 ] 

648 } 

649 ) 

650 

651 

652def test_path_param_le_42(): 5 ctx1abcde

653 response = client.get("/path/param-le/42") 5 ctx2LcMcNcOcPc

654 assert response.status_code == 422 5 ctx2LcMcNcOcPc

655 assert response.json() == IsDict( 5 ctx2LcMcNcOcPc

656 { 

657 "detail": [ 

658 { 

659 "type": "less_than_equal", 

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

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

662 "input": "42", 

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

664 } 

665 ] 

666 } 

667 ) | IsDict( 

668 # TODO: remove when deprecating Pydantic v1 

669 { 

670 "detail": [ 

671 { 

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

673 "msg": "ensure this value is less than or equal to 3", 

674 "type": "value_error.number.not_le", 

675 "ctx": {"limit_value": 3}, 

676 } 

677 ] 

678 } 

679 ) 

680 

681 

682def test_path_param_le_3(): 5 ctx1abcde

683 response = client.get("/path/param-le/3") 5 ctx2QcRcScTcUc

684 assert response.status_code == 200 5 ctx2QcRcScTcUc

685 assert response.json() == 3 5 ctx2QcRcScTcUc

686 

687 

688def test_path_param_le_2(): 5 ctx1abcde

689 response = client.get("/path/param-le/2") 5 ctx2VcWcXcYcZc

690 assert response.status_code == 200 5 ctx2VcWcXcYcZc

691 assert response.json() == 2 5 ctx2VcWcXcYcZc

692 

693 

694def test_path_param_lt_gt_2(): 5 ctx1abcde

695 response = client.get("/path/param-lt-gt/2") 5 ctx20c1c2c3c4c

696 assert response.status_code == 200 5 ctx20c1c2c3c4c

697 assert response.json() == 2 5 ctx20c1c2c3c4c

698 

699 

700def test_path_param_lt_gt_4(): 5 ctx1abcde

701 response = client.get("/path/param-lt-gt/4") 5 ctx25c6c7c8c9c

702 assert response.status_code == 422 5 ctx25c6c7c8c9c

703 assert response.json() == IsDict( 5 ctx25c6c7c8c9c

704 { 

705 "detail": [ 

706 { 

707 "type": "less_than", 

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

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

710 "input": "4", 

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

712 } 

713 ] 

714 } 

715 ) | IsDict( 

716 # TODO: remove when deprecating Pydantic v1 

717 { 

718 "detail": [ 

719 { 

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

721 "msg": "ensure this value is less than 3", 

722 "type": "value_error.number.not_lt", 

723 "ctx": {"limit_value": 3}, 

724 } 

725 ] 

726 } 

727 ) 

728 

729 

730def test_path_param_lt_gt_0(): 5 ctx1abcde

731 response = client.get("/path/param-lt-gt/0") 5 ctx2!c#c$c%c'c

732 assert response.status_code == 422 5 ctx2!c#c$c%c'c

733 assert response.json() == IsDict( 5 ctx2!c#c$c%c'c

734 { 

735 "detail": [ 

736 { 

737 "type": "greater_than", 

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

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

740 "input": "0", 

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

742 } 

743 ] 

744 } 

745 ) | IsDict( 

746 # TODO: remove when deprecating Pydantic v1 

747 { 

748 "detail": [ 

749 { 

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

751 "msg": "ensure this value is greater than 1", 

752 "type": "value_error.number.not_gt", 

753 "ctx": {"limit_value": 1}, 

754 } 

755 ] 

756 } 

757 ) 

758 

759 

760def test_path_param_le_ge_2(): 5 ctx1abcde

761 response = client.get("/path/param-le-ge/2") 5 ctx2(c)c*c+c,c

762 assert response.status_code == 200 5 ctx2(c)c*c+c,c

763 assert response.json() == 2 5 ctx2(c)c*c+c,c

764 

765 

766def test_path_param_le_ge_1(): 5 ctx1abcde

767 response = client.get("/path/param-le-ge/1") 5 ctx2teuevewexe

768 assert response.status_code == 200 5 ctx2teuevewexe

769 

770 

771def test_path_param_le_ge_3(): 5 ctx1abcde

772 response = client.get("/path/param-le-ge/3") 5 ctx2-c.c/c:c;c

773 assert response.status_code == 200 5 ctx2-c.c/c:c;c

774 assert response.json() == 3 5 ctx2-c.c/c:c;c

775 

776 

777def test_path_param_le_ge_4(): 5 ctx1abcde

778 response = client.get("/path/param-le-ge/4") 5 ctx2=c?c@c[c]c

779 assert response.status_code == 422 5 ctx2=c?c@c[c]c

780 assert response.json() == IsDict( 5 ctx2=c?c@c[c]c

781 { 

782 "detail": [ 

783 { 

784 "type": "less_than_equal", 

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

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

787 "input": "4", 

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

789 } 

790 ] 

791 } 

792 ) | IsDict( 

793 # TODO: remove when deprecating Pydantic v1 

794 { 

795 "detail": [ 

796 { 

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

798 "msg": "ensure this value is less than or equal to 3", 

799 "type": "value_error.number.not_le", 

800 "ctx": {"limit_value": 3}, 

801 } 

802 ] 

803 } 

804 ) 

805 

806 

807def test_path_param_lt_int_2(): 5 ctx1abcde

808 response = client.get("/path/param-lt-int/2") 5 ctx2^c_c`c{c|c

809 assert response.status_code == 200 5 ctx2^c_c`c{c|c

810 assert response.json() == 2 5 ctx2^c_c`c{c|c

811 

812 

813def test_path_param_lt_int_42(): 5 ctx1abcde

814 response = client.get("/path/param-lt-int/42") 5 ctx2}c~cadbdcd

815 assert response.status_code == 422 5 ctx2}c~cadbdcd

816 assert response.json() == IsDict( 5 ctx2}c~cadbdcd

817 { 

818 "detail": [ 

819 { 

820 "type": "less_than", 

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

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

823 "input": "42", 

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

825 } 

826 ] 

827 } 

828 ) | IsDict( 

829 # TODO: remove when deprecating Pydantic v1 

830 { 

831 "detail": [ 

832 { 

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

834 "msg": "ensure this value is less than 3", 

835 "type": "value_error.number.not_lt", 

836 "ctx": {"limit_value": 3}, 

837 } 

838 ] 

839 } 

840 ) 

841 

842 

843def test_path_param_lt_int_2_7(): 5 ctx1abcde

844 response = client.get("/path/param-lt-int/2.7") 5 ctx2ddedfdgdhd

845 assert response.status_code == 422 5 ctx2ddedfdgdhd

846 assert response.json() == IsDict( 5 ctx2ddedfdgdhd

847 { 

848 "detail": [ 

849 { 

850 "type": "int_parsing", 

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

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

853 "input": "2.7", 

854 } 

855 ]