Coverage for tests/test_include_router_defaults_overrides.py: 100%

1import warnings 5 ctx1abcde

2 

3import pytest 5 ctx1abcde

4from fastapi import APIRouter, Depends, FastAPI, Response 5 ctx1abcde

5from fastapi.responses import JSONResponse 5 ctx1abcde

6from fastapi.testclient import TestClient 5 ctx1abcde

7 

8 

9class ResponseLevel0(JSONResponse): 5 ctx1abcde

10 media_type = "application/x-level-0" 5 ctx1abcde

11 

12 

13class ResponseLevel1(JSONResponse): 5 ctx1abcde

14 media_type = "application/x-level-1" 5 ctx1abcde

15 

16 

17class ResponseLevel2(JSONResponse): 5 ctx1abcde

18 media_type = "application/x-level-2" 5 ctx1abcde

19 

20 

21class ResponseLevel3(JSONResponse): 5 ctx1abcde

22 media_type = "application/x-level-3" 5 ctx1abcde

23 

24 

25class ResponseLevel4(JSONResponse): 5 ctx1abcde

26 media_type = "application/x-level-4" 5 ctx1abcde

27 

28 

29class ResponseLevel5(JSONResponse): 5 ctx1abcde

30 media_type = "application/x-level-5" 5 ctx1abcde

31 

32 

33async def dep0(response: Response): 5 ctx1abcde

34 response.headers["x-level0"] = "True" 5 ctx1abcde

35 

36 

37async def dep1(response: Response): 5 ctx1abcde

38 response.headers["x-level1"] = "True" 5 ctx1abcde

39 

40 

41async def dep2(response: Response): 5 ctx1abcde

42 response.headers["x-level2"] = "True" 5 ctx1abcde

43 

44 

45async def dep3(response: Response): 5 ctx1abcde

46 response.headers["x-level3"] = "True" 5 ctx1abcde

47 

48 

49async def dep4(response: Response): 5 ctx1abcde

50 response.headers["x-level4"] = "True" 5 ctx1abcde

51 

52 

53async def dep5(response: Response): 5 ctx1abcde

54 response.headers["x-level5"] = "True" 5 ctx1abcde

55 

56 

57callback_router0 = APIRouter() 5 ctx1abcde

58 

59 

60@callback_router0.get("/") 5 ctx1abcde

61async def callback0(level0: str): 5 ctx1abcde

62 pass # pragma: nocover 

63 

64 

65callback_router1 = APIRouter() 5 ctx1abcde

66 

67 

68@callback_router1.get("/") 5 ctx1abcde

69async def callback1(level1: str): 5 ctx1abcde

70 pass # pragma: nocover 

71 

72 

73callback_router2 = APIRouter() 5 ctx1abcde

74 

75 

76@callback_router2.get("/") 5 ctx1abcde

77async def callback2(level2: str): 5 ctx1abcde

78 pass # pragma: nocover 

79 

80 

81callback_router3 = APIRouter() 5 ctx1abcde

82 

83 

84@callback_router3.get("/") 5 ctx1abcde

85async def callback3(level3: str): 5 ctx1abcde

86 pass # pragma: nocover 

87 

88 

89callback_router4 = APIRouter() 5 ctx1abcde

90 

91 

92@callback_router4.get("/") 5 ctx1abcde

93async def callback4(level4: str): 5 ctx1abcde

94 pass # pragma: nocover 

95 

96 

97callback_router5 = APIRouter() 5 ctx1abcde

98 

99 

100@callback_router5.get("/") 5 ctx1abcde

101async def callback5(level5: str): 5 ctx1abcde

102 pass # pragma: nocover 

103 

104 

105app = FastAPI( 5 ctx1abcde

106 dependencies=[Depends(dep0)], 

107 responses={ 

108 400: {"description": "Client error level 0"}, 

109 500: {"description": "Server error level 0"}, 

110 }, 

111 default_response_class=ResponseLevel0, 

112 callbacks=callback_router0.routes, 

113) 

114 

115router2_override = APIRouter( 5 ctx1abcde

116 prefix="/level2", 

117 tags=["level2a", "level2b"], 

118 dependencies=[Depends(dep2)], 

119 responses={ 

120 402: {"description": "Client error level 2"}, 

121 502: {"description": "Server error level 2"}, 

122 }, 

123 default_response_class=ResponseLevel2, 

124 callbacks=callback_router2.routes, 

125 deprecated=True, 

126) 

127router2_default = APIRouter() 5 ctx1abcde

128router4_override = APIRouter( 5 ctx1abcde

129 prefix="/level4", 

130 tags=["level4a", "level4b"], 

131 dependencies=[Depends(dep4)], 

132 responses={ 

133 404: {"description": "Client error level 4"}, 

134 504: {"description": "Server error level 4"}, 

135 }, 

136 default_response_class=ResponseLevel4, 

137 callbacks=callback_router4.routes, 

138 deprecated=True, 

139) 

140router4_default = APIRouter() 5 ctx1abcde

141 

142 

143@app.get( 5 ctx1abcde

144 "/override1", 

145 tags=["path1a", "path1b"], 

146 responses={ 

147 401: {"description": "Client error level 1"}, 

148 501: {"description": "Server error level 1"}, 

149 }, 

150 deprecated=True, 

151 callbacks=callback_router1.routes, 

152 dependencies=[Depends(dep1)], 

153 response_class=ResponseLevel1, 

154) 

155async def path1_override(level1: str): 5 ctx1abcde

156 return level1 5 ctx1abcde

157 

158 

159@app.get("/default1") 5 ctx1abcde

160async def path1_default(level1: str): 5 ctx1abcde

161 return level1 5 ctx1abcde

162 

163 

164@router2_override.get( 5 ctx1abcde

165 "/override3", 

166 tags=["path3a", "path3b"], 

167 responses={ 

168 403: {"description": "Client error level 3"}, 

169 503: {"description": "Server error level 3"}, 

170 }, 

171 deprecated=True, 

172 callbacks=callback_router3.routes, 

173 dependencies=[Depends(dep3)], 

174 response_class=ResponseLevel3, 

175) 

176async def path3_override_router2_override(level3: str): 5 ctx1abcde

177 return level3 5 ctx1abcde

178 

179 

180@router2_override.get("/default3") 5 ctx1abcde

181async def path3_default_router2_override(level3: str): 5 ctx1abcde

182 return level3 5 ctx1abcde

183 

184 

185@router2_default.get( 5 ctx1abcde

186 "/override3", 

187 tags=["path3a", "path3b"], 

188 responses={ 

189 403: {"description": "Client error level 3"}, 

190 503: {"description": "Server error level 3"}, 

191 }, 

192 deprecated=True, 

193 callbacks=callback_router3.routes, 

194 dependencies=[Depends(dep3)], 

195 response_class=ResponseLevel3, 

196) 

197async def path3_override_router2_default(level3: str): 5 ctx1abcde

198 return level3 5 ctx1abcde

199 

200 

201@router2_default.get("/default3") 5 ctx1abcde

202async def path3_default_router2_default(level3: str): 5 ctx1abcde

203 return level3 5 ctx1abcde

204 

205 

206@router4_override.get( 5 ctx1abcde

207 "/override5", 

208 tags=["path5a", "path5b"], 

209 responses={ 

210 405: {"description": "Client error level 5"}, 

211 505: {"description": "Server error level 5"}, 

212 }, 

213 deprecated=True, 

214 callbacks=callback_router5.routes, 

215 dependencies=[Depends(dep5)], 

216 response_class=ResponseLevel5, 

217) 

218async def path5_override_router4_override(level5: str): 5 ctx1abcde

219 return level5 5 ctx1abcde

220 

221 

222@router4_override.get( 5 ctx1abcde

223 "/default5", 

224) 

225async def path5_default_router4_override(level5: str): 5 ctx1abcde

226 return level5 5 ctx1abcde

227 

228 

229@router4_default.get( 5 ctx1abcde

230 "/override5", 

231 tags=["path5a", "path5b"], 

232 responses={ 

233 405: {"description": "Client error level 5"}, 

234 505: {"description": "Server error level 5"}, 

235 }, 

236 deprecated=True, 

237 callbacks=callback_router5.routes, 

238 dependencies=[Depends(dep5)], 

239 response_class=ResponseLevel5, 

240) 

241async def path5_override_router4_default(level5: str): 5 ctx1abcde

242 return level5 5 ctx1abcde

243 

244 

245@router4_default.get( 5 ctx1abcde

246 "/default5", 

247) 

248async def path5_default_router4_default(level5: str): 5 ctx1abcde

249 return level5 5 ctx1abcde

250 

251 

252router2_override.include_router( 5 ctx1abcde

253 router4_override, 

254 prefix="/level3", 

255 tags=["level3a", "level3b"], 

256 dependencies=[Depends(dep3)], 

257 responses={ 

258 403: {"description": "Client error level 3"}, 

259 503: {"description": "Server error level 3"}, 

260 }, 

261 default_response_class=ResponseLevel3, 

262 callbacks=callback_router3.routes, 

263) 

264 

265router2_override.include_router( 5 ctx1abcde

266 router4_default, 

267 prefix="/level3", 

268 tags=["level3a", "level3b"], 

269 dependencies=[Depends(dep3)], 

270 responses={ 

271 403: {"description": "Client error level 3"}, 

272 503: {"description": "Server error level 3"}, 

273 }, 

274 default_response_class=ResponseLevel3, 

275 callbacks=callback_router3.routes, 

276) 

277 

278router2_override.include_router(router4_override) 5 ctx1abcde

279 

280router2_override.include_router(router4_default) 5 ctx1abcde

281 

282router2_default.include_router( 5 ctx1abcde

283 router4_override, 

284 prefix="/level3", 

285 tags=["level3a", "level3b"], 

286 dependencies=[Depends(dep3)], 

287 responses={ 

288 403: {"description": "Client error level 3"}, 

289 503: {"description": "Server error level 3"}, 

290 }, 

291 default_response_class=ResponseLevel3, 

292 callbacks=callback_router3.routes, 

293) 

294 

295router2_default.include_router( 5 ctx1abcde

296 router4_default, 

297 prefix="/level3", 

298 tags=["level3a", "level3b"], 

299 dependencies=[Depends(dep3)], 

300 responses={ 

301 403: {"description": "Client error level 3"}, 

302 503: {"description": "Server error level 3"}, 

303 }, 

304 default_response_class=ResponseLevel3, 

305 callbacks=callback_router3.routes, 

306) 

307 

308router2_default.include_router(router4_override) 5 ctx1abcde

309 

310router2_default.include_router(router4_default) 5 ctx1abcde

311 

312 

313app.include_router( 5 ctx1abcde

314 router2_override, 

315 prefix="/level1", 

316 tags=["level1a", "level1b"], 

317 dependencies=[Depends(dep1)], 

318 responses={ 

319 401: {"description": "Client error level 1"}, 

320 501: {"description": "Server error level 1"}, 

321 }, 

322 default_response_class=ResponseLevel1, 

323 callbacks=callback_router1.routes, 

324) 

325 

326app.include_router( 5 ctx1abcde

327 router2_default, 

328 prefix="/level1", 

329 tags=["level1a", "level1b"], 

330 dependencies=[Depends(dep1)], 

331 responses={ 

332 401: {"description": "Client error level 1"}, 

333 501: {"description": "Server error level 1"}, 

334 }, 

335 default_response_class=ResponseLevel1, 

336 callbacks=callback_router1.routes, 

337) 

338 

339app.include_router(router2_override) 5 ctx1abcde

340 

341app.include_router(router2_default) 5 ctx1abcde

342 

343client = TestClient(app) 5 ctx1abcde

344 

345 

346def test_level1_override(): 5 ctx1abcde

347 response = client.get("/override1?level1=foo") 5 ctx1abcde

348 assert response.json() == "foo" 5 ctx1abcde

349 assert response.headers["content-type"] == "application/x-level-1" 5 ctx1abcde

350 assert "x-level0" in response.headers 5 ctx1abcde

351 assert "x-level1" in response.headers 5 ctx1abcde

352 assert "x-level2" not in response.headers 5 ctx1abcde

353 assert "x-level3" not in response.headers 5 ctx1abcde

354 assert "x-level4" not in response.headers 5 ctx1abcde

355 assert "x-level5" not in response.headers 5 ctx1abcde

356 

357 

358def test_level1_default(): 5 ctx1abcde

359 response = client.get("/default1?level1=foo") 5 ctx1abcde

360 assert response.json() == "foo" 5 ctx1abcde

361 assert response.headers["content-type"] == "application/x-level-0" 5 ctx1abcde

362 assert "x-level0" in response.headers 5 ctx1abcde

363 assert "x-level1" not in response.headers 5 ctx1abcde

364 assert "x-level2" not in response.headers 5 ctx1abcde

365 assert "x-level3" not in response.headers 5 ctx1abcde

366 assert "x-level4" not in response.headers 5 ctx1abcde

367 assert "x-level5" not in response.headers 5 ctx1abcde

368 

369 

370@pytest.mark.parametrize("override1", [True, False]) 5 ctx1abcde

371@pytest.mark.parametrize("override2", [True, False]) 5 ctx1abcde

372@pytest.mark.parametrize("override3", [True, False]) 5 ctx1abcde

373def test_paths_level3(override1, override2, override3): 5 ctx1abcde

374 url = "" 5 ctx1abcde

375 content_type_level = "0" 5 ctx1abcde

376 if override1: 5 ctx1abcde

377 url += "/level1" 5 ctx1abcde

378 content_type_level = "1" 5 ctx1abcde

379 if override2: 5 ctx1abcde

380 url += "/level2" 5 ctx1abcde

381 content_type_level = "2" 5 ctx1abcde

382 if override3: 5 ctx1abcde

383 url += "/override3" 5 ctx1abcde

384 content_type_level = "3" 5 ctx1abcde

385 else: 

386 url += "/default3" 5 ctx1abcde

387 url += "?level3=foo" 5 ctx1abcde

388 response = client.get(url) 5 ctx1abcde

389 assert response.json() == "foo" 5 ctx1abcde

390 assert ( 5 ctx1abcde

391 response.headers["content-type"] == f"application/x-level-{content_type_level}" 

392 ) 

393 assert "x-level0" in response.headers 5 ctx1abcde

394 assert not override1 or "x-level1" in response.headers 5 ctx1abcde

395 assert not override2 or "x-level2" in response.headers 5 ctx1abcde

396 assert not override3 or "x-level3" in response.headers 5 ctx1abcde

397 

398 

399@pytest.mark.parametrize("override1", [True, False]) 5 ctx1abcde

400@pytest.mark.parametrize("override2", [True, False]) 5 ctx1abcde

401@pytest.mark.parametrize("override3", [True, False]) 5 ctx1abcde

402@pytest.mark.parametrize("override4", [True, False]) 5 ctx1abcde

403@pytest.mark.parametrize("override5", [True, False]) 5 ctx1abcde

404def test_paths_level5(override1, override2, override3, override4, override5): 5 ctx1abcde

405 url = "" 5 ctx1abcde

406 content_type_level = "0" 5 ctx1abcde

407 if override1: 5 ctx1abcde

408 url += "/level1" 5 ctx1abcde

409 content_type_level = "1" 5 ctx1abcde

410 if override2: 5 ctx1abcde

411 url += "/level2" 5 ctx1abcde

412 content_type_level = "2" 5 ctx1abcde

413 if override3: 5 ctx1abcde

414 url += "/level3" 5 ctx1abcde

415 content_type_level = "3" 5 ctx1abcde

416 if override4: 5 ctx1abcde

417 url += "/level4" 5 ctx1abcde

418 content_type_level = "4" 5 ctx1abcde

419 if override5: 5 ctx1abcde

420 url += "/override5" 5 ctx1abcde

421 content_type_level = "5" 5 ctx1abcde

422 else: 

423 url += "/default5" 5 ctx1abcde

424 url += "?level5=foo" 5 ctx1abcde

425 response = client.get(url) 5 ctx1abcde

426 assert response.json() == "foo" 5 ctx1abcde

427 assert ( 5 ctx1abcde

428 response.headers["content-type"] == f"application/x-level-{content_type_level}" 

429 ) 

430 assert "x-level0" in response.headers 5 ctx1abcde

431 assert not override1 or "x-level1" in response.headers 5 ctx1abcde

432 assert not override2 or "x-level2" in response.headers 5 ctx1abcde

433 assert not override3 or "x-level3" in response.headers 5 ctx1abcde

434 assert not override4 or "x-level4" in response.headers 5 ctx1abcde

435 assert not override5 or "x-level5" in response.headers 5 ctx1abcde

436 

437 

438def test_openapi(): 5 ctx1abcde

439 client = TestClient(app) 5 ctx1abcde

440 with warnings.catch_warnings(record=True) as w: 5 ctx1abcde

441 warnings.simplefilter("always") 5 ctx1abcde

442 response = client.get("/openapi.json") 5 ctx1abcde

443 assert issubclass(w[-1].category, UserWarning) 5 ctx1abcde

444 assert "Duplicate Operation ID" in str(w[-1].message) 5 ctx1abcde

445 assert response.json() == { 5 ctx1abcde

446 "openapi": "3.1.0", 

447 "info": {"title": "FastAPI", "version": "0.1.0"}, 

448 "paths": { 

449 "/override1": { 

450 "get": { 

451 "tags": ["path1a", "path1b"], 

452 "summary": "Path1 Override", 

453 "operationId": "path1_override_override1_get", 

454 "parameters": [ 

455 { 

456 "required": True, 

457 "schema": {"title": "Level1", "type": "string"}, 

458 "name": "level1", 

459 "in": "query", 

460 } 

461 ], 

462 "responses": { 

463 "200": { 

464 "description": "Successful Response", 

465 "content": {"application/x-level-1": {"schema": {}}}, 

466 }, 

467 "400": {"description": "Client error level 0"}, 

468 "401": {"description": "Client error level 1"}, 

469 "422": { 

470 "description": "Validation Error", 

471 "content": { 

472 "application/json": { 

473 "schema": { 

474 "$ref": "#/components/schemas/HTTPValidationError" 

475 } 

476 } 

477 }, 

478 }, 

479 "500": {"description": "Server error level 0"}, 

480 "501": {"description": "Server error level 1"}, 

481 }, 

482 "callbacks": { 

483 "callback0": { 

484 "/": { 

485 "get": { 

486 "summary": "Callback0", 

487 "operationId": "callback0__get", 

488 "parameters": [ 

489 { 

490 "name": "level0", 

491 "in": "query", 

492 "required": True, 

493 "schema": { 

494 "title": "Level0", 

495 "type": "string", 

496 }, 

497 } 

498 ], 

499 "responses": { 

500 "200": { 

501 "description": "Successful Response", 

502 "content": { 

503 "application/json": {"schema": {}} 

504 }, 

505 }, 

506 "422": { 

507 "description": "Validation Error", 

508 "content": { 

509 "application/json": { 

510 "schema": { 

511 "$ref": "#/components/schemas/HTTPValidationError" 

512 } 

513 } 

514 }, 

515 }, 

516 }, 

517 } 

518 } 

519 }, 

520 "callback1": { 

521 "/": { 

522 "get": { 

523 "summary": "Callback1", 

524 "operationId": "callback1__get", 

525 "parameters": [ 

526 { 

527 "name": "level1", 

528 "in": "query", 

529 "required": True, 

530 "schema": { 

531 "title": "Level1", 

532 "type": "string", 

533 }, 

534 } 

535 ], 

536 "responses": { 

537 "200": { 

538 "description": "Successful Response", 

539 "content": { 

540 "application/json": {"schema": {}} 

541 }, 

542 }, 

543 "422": { 

544 "description": "Validation Error", 

545 "content": { 

546 "application/json": { 

547 "schema": { 

548 "$ref": "#/components/schemas/HTTPValidationError" 

549 } 

550 } 

551 }, 

552 }, 

553 }, 

554 } 

555 } 

556 }, 

557 }, 

558 "deprecated": True, 

559 } 

560 }, 

561 "/default1": { 

562 "get": { 

563 "summary": "Path1 Default", 

564 "operationId": "path1_default_default1_get", 

565 "parameters": [ 

566 { 

567 "required": True, 

568 "schema": {"title": "Level1", "type": "string"}, 

569 "name": "level1", 

570 "in": "query", 

571 } 

572 ], 

573 "responses": { 

574 "200": { 

575 "description": "Successful Response", 

576 "content": {"application/x-level-0": {"schema": {}}}, 

577 }, 

578 "400": {"description": "Client error level 0"}, 

579 "422": { 

580 "description": "Validation Error", 

581 "content": { 

582 "application/json": { 

583 "schema": { 

584 "$ref": "#/components/schemas/HTTPValidationError" 

585 } 

586 } 

587 }, 

588 }, 

589 "500": {"description": "Server error level 0"}, 

590 }, 

591 "callbacks": { 

592 "callback0": { 

593 "/": { 

594 "get": { 

595 "summary": "Callback0", 

596 "operationId": "callback0__get", 

597 "parameters": [ 

598 { 

599 "name": "level0", 

600 "in": "query", 

601 "required": True, 

602 "schema": { 

603 "title": "Level0", 

604 "type": "string", 

605 }, 

606 } 

607 ], 

608 "responses": { 

609 "200": { 

610 "description": "Successful Response", 

611 "content": { 

612 "application/json": {"schema": {}} 

613 }, 

614 }, 

615 "422": { 

616 "description": "Validation Error", 

617 "content": { 

618 "application/json": { 

619 "schema": { 

620 "$ref": "#/components/schemas/HTTPValidationError" 

621 } 

622 } 

623 }, 

624 }, 

625 }, 

626 } 

627 } 

628 } 

629 }, 

630 } 

631 }, 

632 "/level1/level2/override3": { 

633 "get": { 

634 "tags": [ 

635 "level1a", 

636 "level1b", 

637 "level2a", 

638 "level2b", 

639 "path3a", 

640 "path3b", 

641 ], 

642 "summary": "Path3 Override Router2 Override", 

643 "operationId": "path3_override_router2_override_level1_level2_override3_get", 

644 "parameters": [ 

645 { 

646 "required": True, 

647 "schema": {"title": "Level3", "type": "string"}, 

648 "name": "level3", 

649 "in": "query", 

650 } 

651 ], 

652 "responses": { 

653 "200": { 

654 "description": "Successful Response", 

655 "content": {"application/x-level-3": {"schema": {}}}, 

656 }, 

657 "400": {"description": "Client error level 0"}, 

658 "401": {"description": "Client error level 1"}, 

659 "402": {"description": "Client error level 2"}, 

660 "403": {"description": "Client error level 3"}, 

661 "422": { 

662 "description": "Validation Error", 

663 "content": { 

664 "application/json": { 

665 "schema": { 

666 "$ref": "#/components/schemas/HTTPValidationError" 

667 } 

668 } 

669 }, 

670 }, 

671 "500": {"description": "Server error level 0"}, 

672 "501": {"description": "Server error level 1"}, 

673 "502": {"description": "Server error level 2"}, 

674 "503": {"description": "Server error level 3"}, 

675 }, 

676 "callbacks": { 

677 "callback0": { 

678 "/": { 

679 "get": { 

680 "summary": "Callback0", 

681 "operationId": "callback0__get", 

682 "parameters": [ 

683 { 

684 "name": "level0", 

685 "in": "query", 

686 "required": True, 

687 "schema": { 

688 "title": "Level0", 

689 "type": "string", 

690 }, 

691 } 

692 ], 

693 "responses": { 

694 "200": { 

695 "description": "Successful Response", 

696 "content": { 

697 "application/json": {"schema": {}} 

698 }, 

699 }, 

700 "422": { 

701 "description": "Validation Error", 

702 "content": { 

703 "application/json": { 

704 "schema": { 

705 "$ref": "#/components/schemas/HTTPValidationError" 

706 } 

707 } 

708 }, 

709 }, 

710 }, 

711 } 

712 } 

713 }, 

714 "callback1": { 

715 "/": { 

716 "get": { 

717 "summary": "Callback1", 

718 "operationId": "callback1__get", 

719 "parameters": [ 

720 { 

721 "name": "level1", 

722 "in": "query", 

723 "required": True, 

724 "schema": { 

725 "title": "Level1", 

726 "type": "string", 

727 }, 

728 } 

729 ], 

730 "responses": { 

731 "200": { 

732 "description": "Successful Response", 

733 "content": { 

734 "application/json": {"schema": {}} 

735 }, 

736 }, 

737 "422": { 

738 "description": "Validation Error", 

739 "content": { 

740 "application/json": { 

741 "schema": { 

742 "$ref": "#/components/schemas/HTTPValidationError" 

743 } 

744 } 

745 }, 

746 }, 

747 }, 

748 } 

749 } 

750 }, 

751 "callback2": { 

752 "/": { 

753 "get": { 

754 "summary": "Callback2", 

755 "operationId": "callback2__get", 

756 "parameters": [ 

757 { 

758 "name": "level2", 

759 "in": "query", 

760 "required": True, 

761 "schema": { 

762 "title": "Level2", 

763 "type": "string", 

764 }, 

765 } 

766 ], 

767 "responses": { 

768 "200": { 

769 "description": "Successful Response", 

770 "content": { 

771 "application/json": {"schema": {}} 

772 }, 

773 }, 

774 "422": { 

775 "description": "Validation Error", 

776 "content": { 

777 "application/json": { 

778 "schema": { 

779 "$ref": "#/components/schemas/HTTPValidationError" 

780 } 

781 } 

782 }, 

783 }, 

784 }, 

785 } 

786 } 

787 }, 

788 "callback3": { 

789 "/": { 

790 "get": { 

791 "summary": "Callback3", 

792 "operationId": "callback3__get", 

793 "parameters": [ 

794 { 

795 "name": "level3", 

796 "in": "query", 

797 "required": True, 

798 "schema": { 

799 "title": "Level3", 

800 "type": "string", 

801 }, 

802 } 

803 ], 

804 "responses": { 

805 "200": { 

806 "description": "Successful Response", 

807 "content": { 

808 "application/json": {"schema": {}} 

809 }, 

810 }, 

811 "422": { 

812 "description": "Validation Error", 

813 "content": { 

814 "application/json": { 

815 "schema": { 

816 "$ref": "#/components/schemas/HTTPValidationError" 

817 } 

818 } 

819 }, 

820 }, 

821 }, 

822 } 

823 } 

824 }, 

825 }, 

826 "deprecated": True, 

827 } 

828 }, 

829 "/level1/level2/default3": { 

830 "get": { 

831 "tags": ["level1a", "level1b", "level2a", "level2b"], 

832 "summary": "Path3 Default Router2 Override", 

833 "operationId": "path3_default_router2_override_level1_level2_default3_get", 

834 "parameters": [ 

835 { 

836 "required": True, 

837 "schema": {"title": "Level3", "type": "string"}, 

838 "name": "level3", 

839 "in": "query", 

840 } 

841 ], 

842 "responses": { 

843 "200": { 

844 "description": "Successful Response", 

845 "content": {"application/x-level-2": {"schema": {}}}, 

846 },