fastapi

1
from typing import Optional
2

3
import pytest
4
from dirty_equals import IsDict
5
from fastapi import APIRouter, Depends, FastAPI
6
from fastapi.testclient import TestClient
7
from fastapi.utils import match_pydantic_error_url
8

9
app = FastAPI()
10

11
router = APIRouter()
12

13

14
async def common_parameters(q: str, skip: int = 0, limit: int = 100):
15
    return {"q": q, "skip": skip, "limit": limit}
16

17

18
@app.get("/main-depends/")
19
async def main_depends(commons: dict = Depends(common_parameters)):
20
    return {"in": "main-depends", "params": commons}
21

22

23
@app.get("/decorator-depends/", dependencies=[Depends(common_parameters)])
24
async def decorator_depends():
25
    return {"in": "decorator-depends"}
26

27

28
@router.get("/router-depends/")
29
async def router_depends(commons: dict = Depends(common_parameters)):
30
    return {"in": "router-depends", "params": commons}
31

32

33
@router.get("/router-decorator-depends/", dependencies=[Depends(common_parameters)])
34
async def router_decorator_depends():
35
    return {"in": "router-decorator-depends"}
36

37

38
app.include_router(router)
39

40
client = TestClient(app)
41

42

43
async def overrider_dependency_simple(q: Optional[str] = None):
44
    return {"q": q, "skip": 5, "limit": 10}
45

46

47
async def overrider_sub_dependency(k: str):
48
    return {"k": k}
49

50

51
async def overrider_dependency_with_sub(msg: dict = Depends(overrider_sub_dependency)):
52
    return msg
53

54

55
def test_main_depends():
56
    response = client.get("/main-depends/")
57
    assert response.status_code == 422
58
    assert response.json() == IsDict(
59
        {
60
            "detail": [
61
                {
62
                    "type": "missing",
63
                    "loc": ["query", "q"],
64
                    "msg": "Field required",
65
                    "input": None,
66
                    "url": match_pydantic_error_url("missing"),
67
                }
68
            ]
69
        }
70
    ) | IsDict(
71
        # TODO: remove when deprecating Pydantic v1
72
        {
73
            "detail": [
74
                {
75
                    "loc": ["query", "q"],
76
                    "msg": "field required",
77
                    "type": "value_error.missing",
78
                }
79
            ]
80
        }
81
    )
82

83

84
def test_main_depends_q_foo():
85
    response = client.get("/main-depends/?q=foo")
86
    assert response.status_code == 200
87
    assert response.json() == {
88
        "in": "main-depends",
89
        "params": {"q": "foo", "skip": 0, "limit": 100},
90
    }
91

92

93
def test_main_depends_q_foo_skip_100_limit_200():
94
    response = client.get("/main-depends/?q=foo&skip=100&limit=200")
95
    assert response.status_code == 200
96
    assert response.json() == {
97
        "in": "main-depends",
98
        "params": {"q": "foo", "skip": 100, "limit": 200},
99
    }
100

101

102
def test_decorator_depends():
103
    response = client.get("/decorator-depends/")
104
    assert response.status_code == 422
105
    assert response.json() == IsDict(
106
        {
107
            "detail": [
108
                {
109
                    "type": "missing",
110
                    "loc": ["query", "q"],
111
                    "msg": "Field required",
112
                    "input": None,
113
                    "url": match_pydantic_error_url("missing"),
114
                }
115
            ]
116
        }
117
    ) | IsDict(
118
        # TODO: remove when deprecating Pydantic v1
119
        {
120
            "detail": [
121
                {
122
                    "loc": ["query", "q"],
123
                    "msg": "field required",
124
                    "type": "value_error.missing",
125
                }
126
            ]
127
        }
128
    )
129

130

131
def test_decorator_depends_q_foo():
132
    response = client.get("/decorator-depends/?q=foo")
133
    assert response.status_code == 200
134
    assert response.json() == {"in": "decorator-depends"}
135

136

137
def test_decorator_depends_q_foo_skip_100_limit_200():
138
    response = client.get("/decorator-depends/?q=foo&skip=100&limit=200")
139
    assert response.status_code == 200
140
    assert response.json() == {"in": "decorator-depends"}
141

142

143
def test_router_depends():
144
    response = client.get("/router-depends/")
145
    assert response.status_code == 422
146
    assert response.json() == IsDict(
147
        {
148
            "detail": [
149
                {
150
                    "type": "missing",
151
                    "loc": ["query", "q"],
152
                    "msg": "Field required",
153
                    "input": None,
154
                    "url": match_pydantic_error_url("missing"),
155
                }
156
            ]
157
        }
158
    ) | IsDict(
159
        # TODO: remove when deprecating Pydantic v1
160
        {
161
            "detail": [
162
                {
163
                    "loc": ["query", "q"],
164
                    "msg": "field required",
165
                    "type": "value_error.missing",
166
                }
167
            ]
168
        }
169
    )
170

171

172
def test_router_depends_q_foo():
173
    response = client.get("/router-depends/?q=foo")
174
    assert response.status_code == 200
175
    assert response.json() == {
176
        "in": "router-depends",
177
        "params": {"q": "foo", "skip": 0, "limit": 100},
178
    }
179

180

181
def test_router_depends_q_foo_skip_100_limit_200():
182
    response = client.get("/router-depends/?q=foo&skip=100&limit=200")
183
    assert response.status_code == 200
184
    assert response.json() == {
185
        "in": "router-depends",
186
        "params": {"q": "foo", "skip": 100, "limit": 200},
187
    }
188

189

190
def test_router_decorator_depends():
191
    response = client.get("/router-decorator-depends/")
192
    assert response.status_code == 422
193
    assert response.json() == IsDict(
194
        {
195
            "detail": [
196
                {
197
                    "type": "missing",
198
                    "loc": ["query", "q"],
199
                    "msg": "Field required",
200
                    "input": None,
201
                    "url": match_pydantic_error_url("missing"),
202
                }
203
            ]
204
        }
205
    ) | IsDict(
206
        # TODO remove when deprecating Pydantic v1
207
        {
208
            "detail": [
209
                {
210
                    "loc": ["query", "q"],
211
                    "msg": "field required",
212
                    "type": "value_error.missing",
213
                }
214
            ]
215
        }
216
    )
217

218

219
def test_router_decorator_depends_q_foo():
220
    response = client.get("/router-decorator-depends/?q=foo")
221
    assert response.status_code == 200
222
    assert response.json() == {"in": "router-decorator-depends"}
223

224

225
def test_router_decorator_depends_q_foo_skip_100_limit_200():
226
    response = client.get("/router-decorator-depends/?q=foo&skip=100&limit=200")
227
    assert response.status_code == 200
228
    assert response.json() == {"in": "router-decorator-depends"}
229

230

231
@pytest.mark.parametrize(
232
    "url,status_code,expected",
233
    [
234
        (
235
            "/main-depends/",
236
            200,
237
            {"in": "main-depends", "params": {"q": None, "skip": 5, "limit": 10}},
238
        ),
239
        (
240
            "/main-depends/?q=foo",
241
            200,
242
            {"in": "main-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
243
        ),
244
        (
245
            "/main-depends/?q=foo&skip=100&limit=200",
246
            200,
247
            {"in": "main-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
248
        ),
249
        ("/decorator-depends/", 200, {"in": "decorator-depends"}),
250
        (
251
            "/router-depends/",
252
            200,
253
            {"in": "router-depends", "params": {"q": None, "skip": 5, "limit": 10}},
254
        ),
255
        (
256
            "/router-depends/?q=foo",
257
            200,
258
            {"in": "router-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
259
        ),
260
        (
261
            "/router-depends/?q=foo&skip=100&limit=200",
262
            200,
263
            {"in": "router-depends", "params": {"q": "foo", "skip": 5, "limit": 10}},
264
        ),
265
        ("/router-decorator-depends/", 200, {"in": "router-decorator-depends"}),
266
    ],
267
)
268
def test_override_simple(url, status_code, expected):
269
    app.dependency_overrides[common_parameters] = overrider_dependency_simple
270
    response = client.get(url)
271
    assert response.status_code == status_code
272
    assert response.json() == expected
273
    app.dependency_overrides = {}
274

275

276
def test_override_with_sub_main_depends():
277
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
278
    response = client.get("/main-depends/")
279
    assert response.status_code == 422
280
    assert response.json() == IsDict(
281
        {
282
            "detail": [
283
                {
284
                    "type": "missing",
285
                    "loc": ["query", "k"],
286
                    "msg": "Field required",
287
                    "input": None,
288
                    "url": match_pydantic_error_url("missing"),
289
                }
290
            ]
291
        }
292
    ) | IsDict(
293
        # TODO: remove when deprecating Pydantic v1
294
        {
295
            "detail": [
296
                {
297
                    "loc": ["query", "k"],
298
                    "msg": "field required",
299
                    "type": "value_error.missing",
300
                }
301
            ]
302
        }
303
    )
304
    app.dependency_overrides = {}
305

306

307
def test_override_with_sub__main_depends_q_foo():
308
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
309
    response = client.get("/main-depends/?q=foo")
310
    assert response.status_code == 422
311
    assert response.json() == IsDict(
312
        {
313
            "detail": [
314
                {
315
                    "type": "missing",
316
                    "loc": ["query", "k"],
317
                    "msg": "Field required",
318
                    "input": None,
319
                    "url": match_pydantic_error_url("missing"),
320
                }
321
            ]
322
        }
323
    ) | IsDict(
324
        # TODO: remove when deprecating Pydantic v1
325
        {
326
            "detail": [
327
                {
328
                    "loc": ["query", "k"],
329
                    "msg": "field required",
330
                    "type": "value_error.missing",
331
                }
332
            ]
333
        }
334
    )
335
    app.dependency_overrides = {}
336

337

338
def test_override_with_sub_main_depends_k_bar():
339
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
340
    response = client.get("/main-depends/?k=bar")
341
    assert response.status_code == 200
342
    assert response.json() == {"in": "main-depends", "params": {"k": "bar"}}
343
    app.dependency_overrides = {}
344

345

346
def test_override_with_sub_decorator_depends():
347
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
348
    response = client.get("/decorator-depends/")
349
    assert response.status_code == 422
350
    assert response.json() == IsDict(
351
        {
352
            "detail": [
353
                {
354
                    "type": "missing",
355
                    "loc": ["query", "k"],
356
                    "msg": "Field required",
357
                    "input": None,
358
                    "url": match_pydantic_error_url("missing"),
359
                }
360
            ]
361
        }
362
    ) | IsDict(
363
        # TODO: remove when deprecating Pydantic v1
364
        {
365
            "detail": [
366
                {
367
                    "loc": ["query", "k"],
368
                    "msg": "field required",
369
                    "type": "value_error.missing",
370
                }
371
            ]
372
        }
373
    )
374
    app.dependency_overrides = {}
375

376

377
def test_override_with_sub_decorator_depends_q_foo():
378
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
379
    response = client.get("/decorator-depends/?q=foo")
380
    assert response.status_code == 422
381
    assert response.json() == IsDict(
382
        {
383
            "detail": [
384
                {
385
                    "type": "missing",
386
                    "loc": ["query", "k"],
387
                    "msg": "Field required",
388
                    "input": None,
389
                    "url": match_pydantic_error_url("missing"),
390
                }
391
            ]
392
        }
393
    ) | IsDict(
394
        # TODO: remove when deprecating Pydantic v1
395
        {
396
            "detail": [
397
                {
398
                    "loc": ["query", "k"],
399
                    "msg": "field required",
400
                    "type": "value_error.missing",
401
                }
402
            ]
403
        }
404
    )
405
    app.dependency_overrides = {}
406

407

408
def test_override_with_sub_decorator_depends_k_bar():
409
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
410
    response = client.get("/decorator-depends/?k=bar")
411
    assert response.status_code == 200
412
    assert response.json() == {"in": "decorator-depends"}
413
    app.dependency_overrides = {}
414

415

416
def test_override_with_sub_router_depends():
417
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
418
    response = client.get("/router-depends/")
419
    assert response.status_code == 422
420
    assert response.json() == IsDict(
421
        {
422
            "detail": [
423
                {
424
                    "type": "missing",
425
                    "loc": ["query", "k"],
426
                    "msg": "Field required",
427
                    "input": None,
428
                    "url": match_pydantic_error_url("missing"),
429
                }
430
            ]
431
        }
432
    ) | IsDict(
433
        # TODO remove when deprecating Pydantic v1
434
        {
435
            "detail": [
436
                {
437
                    "loc": ["query", "k"],
438
                    "msg": "field required",
439
                    "type": "value_error.missing",
440
                }
441
            ]
442
        }
443
    )
444
    app.dependency_overrides = {}
445

446

447
def test_override_with_sub_router_depends_q_foo():
448
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
449
    response = client.get("/router-depends/?q=foo")
450
    assert response.status_code == 422
451
    assert response.json() == IsDict(
452
        {
453
            "detail": [
454
                {
455
                    "type": "missing",
456
                    "loc": ["query", "k"],
457
                    "msg": "Field required",
458
                    "input": None,
459
                    "url": match_pydantic_error_url("missing"),
460
                }
461
            ]
462
        }
463
    ) | IsDict(
464
        # TODO remove when deprecating Pydantic v1
465
        {
466
            "detail": [
467
                {
468
                    "loc": ["query", "k"],
469
                    "msg": "field required",
470
                    "type": "value_error.missing",
471
                }
472
            ]
473
        }
474
    )
475
    app.dependency_overrides = {}
476

477

478
def test_override_with_sub_router_depends_k_bar():
479
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
480
    response = client.get("/router-depends/?k=bar")
481
    assert response.status_code == 200
482
    assert response.json() == {"in": "router-depends", "params": {"k": "bar"}}
483
    app.dependency_overrides = {}
484

485

486
def test_override_with_sub_router_decorator_depends():
487
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
488
    response = client.get("/router-decorator-depends/")
489
    assert response.status_code == 422
490
    assert response.json() == IsDict(
491
        {
492
            "detail": [
493
                {
494
                    "type": "missing",
495
                    "loc": ["query", "k"],
496
                    "msg": "Field required",
497
                    "input": None,
498
                    "url": match_pydantic_error_url("missing"),
499
                }
500
            ]
501
        }
502
    ) | IsDict(
503
        # TODO remove when deprecating Pydantic v1
504
        {
505
            "detail": [
506
                {
507
                    "loc": ["query", "k"],
508
                    "msg": "field required",
509
                    "type": "value_error.missing",
510
                }
511
            ]
512
        }
513
    )
514
    app.dependency_overrides = {}
515

516

517
def test_override_with_sub_router_decorator_depends_q_foo():
518
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
519
    response = client.get("/router-decorator-depends/?q=foo")
520
    assert response.status_code == 422
521
    assert response.json() == IsDict(
522
        {
523
            "detail": [
524
                {
525
                    "type": "missing",
526
                    "loc": ["query", "k"],
527
                    "msg": "Field required",
528
                    "input": None,
529
                    "url": match_pydantic_error_url("missing"),
530
                }
531
            ]
532
        }
533
    ) | IsDict(
534
        # TODO remove when deprecating Pydantic v1
535
        {
536
            "detail": [
537
                {
538
                    "loc": ["query", "k"],
539
                    "msg": "field required",
540
                    "type": "value_error.missing",
541
                }
542
            ]
543
        }
544
    )
545
    app.dependency_overrides = {}
546

547

548
def test_override_with_sub_router_decorator_depends_k_bar():
549
    app.dependency_overrides[common_parameters] = overrider_dependency_with_sub
550
    response = client.get("/router-decorator-depends/?k=bar")
551
    assert response.status_code == 200
552
    assert response.json() == {"in": "router-decorator-depends"}
553
    app.dependency_overrides = {}
554