3876649721

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/neurobagel/bagelapi/commit/<a class=hub.com/neurobagel/api/commit/c095362fe91152f628905c8213f5ce49360f7c64">c095362fe<a href="https://github.com/neurobagel/api/commit/c095362fe91152f628905c8213f5ce49360f7c64">">Merge </a><a class="double-link" href="https://github.com/neurobagel/bagelapi/commit/<a class="double-link" href="https://github.com/neurobagel/api/commit/b4719f80c5bb1272c198b18075221ce34845ff28">b4719f80c</a>">b4719f80c</a><a href="https://github.com/neurobagel/bagelapi/commit/c095362fe91152f628905c8213f5ce49360f7c64"> into 59c4dd8b3">59c4dd8b3</a>

Pull Request Pull Request #46: Implemented minimum number of imaging sessions query parameter

Run Details

53 of 53 new or added lines in 3 files covered. (100.0%)

226 of 246 relevant lines covered (91.87%)

0.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.2

/tests/test_query.py

"""Test API to query subjects from the Stardog graph who match user-specified criteria."""

import httpx
import pytest
from fastapi import HTTPException

from app.api import crud


@pytest.fixture
def test_data():
    """Create toy data for two subjects for testing."""
    data = [
        {
            "number_session": "test1",
            "modality": "test1",
            "subject": "test1",
            "sub_id": "test1",
            "sex": "test1",
            "diagnosis": "test1",
            "dataset_name": "test1",
            "dataset": "test1",
            "age": "test1",
        },
        {
            "number_session": "test2",
            "modality": "test2",
            "subject": "test2",
            "sub_id": "test2",
            "sex": "test2",
            "diagnosis": "test2",
            "dataset_name": "test2",
            "dataset": "test2",
            "age": "test2",
        },
    ]
    return data


@pytest.fixture
def mock_successful_get(test_data):
    """Mock get function that returns non-empty query results."""

    async def mockreturn(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return test_data

    return mockreturn


def test_start_app_without_environment_vars_fails(test_app, monkeypatch):
    """Given non-existing USER and PASSWORD environment variables, raises an informative RuntimeError."""
    monkeypatch.delenv("USER", raising=False)
    monkeypatch.delenv("PASSWORD", raising=False)

    with pytest.raises(RuntimeError) as e_info:
        with test_app:
            pass
    assert (
        "could not find the USER and / or PASSWORD environment variables"
        in str(e_info.value)
    )


def test_app_with_invalid_environment_vars(test_app, monkeypatch):
    """Given invalid environment variables, returns a 401 status code."""
    monkeypatch.setenv("USER", "something")
    monkeypatch.setenv("PASSWORD", "cool")

    def mock_httpx_post(**kwargs):
        return httpx.Response(status_code=401)

    monkeypatch.setattr(httpx, "post", mock_httpx_post)
    response = test_app.get("/query/")
    assert response.status_code == 401


def test_get_all(test_app, mock_successful_get, monkeypatch):
    """Given no input for the sex parameter, returns a 200 status code and a non-empty list of results (should correspond to all subjects in graph)."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get("/query/")
    assert response.status_code == 200
    assert response.json() != []


@pytest.mark.parametrize(
    "valid_age_min, valid_age_max",
    [(30.5, 60), (23, 23)],
)
def test_get_valid_age_range(
    test_app, mock_successful_get, valid_age_min, valid_age_max, monkeypatch
):
    """Given a valid age range, returns a 200 status code and a non-empty list of results."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get(
        f"/query/?age_min={valid_age_min}&age_max={valid_age_max}"
    )
    assert response.status_code == 200
    assert response.json() != []


@pytest.mark.parametrize(
    "age_keyval",
    ["age_min=20.75", "age_max=50"],
)
def test_get_valid_age_single_bound(
    test_app, mock_successful_get, age_keyval, monkeypatch
):
    """Given only a valid lower/upper age bound, returns a 200 status code and a non-empty list of results."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get(f"/query/?{age_keyval}")
    assert response.status_code == 200
    assert response.json() != []


@pytest.mark.parametrize(
    "invalid_age_min, invalid_age_max",
    [
        ("forty", "fifty"),
        (33, 21),
        (-42.5, -40),
    ],
)
def test_get_invalid_age(
    test_app, invalid_age_min, invalid_age_max, monkeypatch
):
    """Given an invalid age range, returns a 422 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return None

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get(
        f"/query/?age_min={invalid_age_min}&age_max={invalid_age_max}"
    )
    assert response.status_code == 422


@pytest.mark.parametrize("valid_sex", ["male", "female", "other"])
def test_get_valid_sex(test_app, mock_successful_get, valid_sex, monkeypatch):
    """Given a valid sex string, returns a 200 status code and a non-empty list of results."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get(f"/query/?sex={valid_sex}")
    assert response.status_code == 200
    assert response.json() != []


def test_get_invalid_sex(test_app, monkeypatch):
    """Given an invalid sex string (i.e., anything other than ["male", "female", None]), returns a 422 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return None

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get("/query/?sex=apple")
    assert response.status_code == 422


@pytest.mark.parametrize(
    "valid_diagnosis", ["snomed:35489007", "snomed:49049000"]
)
def test_get_valid_diagnosis(
    test_app, mock_successful_get, valid_diagnosis, monkeypatch
):
    """Given a valid diagnosis, returns a 200 status code and a non-empty list of results."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get(f"/query/?diagnosis={valid_diagnosis}")
    assert response.status_code == 200
    assert response.json() != []


@pytest.mark.parametrize(
    "invalid_diagnosis", ["sn0med:35489007", "apple", ":123456"]
)
def test_get_invalid_diagnosis(test_app, invalid_diagnosis, monkeypatch):
    """Given an invalid diagnosis, returns a 422 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return None

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get(f"/query/?diagnosis={invalid_diagnosis}")
    assert response.status_code == 422


@pytest.mark.parametrize("valid_iscontrol", [True, False])
def test_get_valid_iscontrol(
    test_app, mock_successful_get, valid_iscontrol, monkeypatch
):
    """Given a valid is_control value, returns a 200 status code and a non-empty list of results."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get(f"/query/?is_control={valid_iscontrol}")
    assert response.status_code == 200
    assert response.json() != []


def test_get_invalid_iscontrol(test_app, monkeypatch):
    """Given a non-boolean is_control value, returns a 422 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return None

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get("/query/?is_control=apple")
    assert response.status_code == 422


def test_get_invalid_control_diagnosis_pair(test_app, monkeypatch):
    """Given a non-default diagnosis value and is_control value of True, returns a 422 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return None

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get(
        "/query/?diagnosis=snomed:35489007&is_control=True"
    )
    assert response.status_code == 422
    assert (
        "Subjects cannot both be healthy controls and have a diagnosis"
        in response.text
    )


@pytest.mark.parametrize("valid_min_num_sessions", [1, 2, 4, 7])
def test_get_valid_min_num_sessions(
    test_app, mock_successful_get, valid_min_num_sessions, monkeypatch
):
    """Given a valid minimum number of imaging sessions, returns a 200 status code and a non-empty list of results."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get(
        f"/query/?min_num_sessions={valid_min_num_sessions}"
    )
    assert response.status_code == 200
    assert response.json() != []


@pytest.mark.parametrize("invalid_min_num_sessions", [0, -3, "apple"])
def test_get_invalid_min_num_sessions(
    test_app, invalid_min_num_sessions, monkeypatch
):
    """Given an invalid minimum number of imaging sessions, returns a 422 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return None

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get(
        f"/query/?min_num_sessions={invalid_min_num_sessions}"
    )
    response.status_code = 422


@pytest.mark.parametrize(
    "valid_available_image_modal",
    [
        "nidm:DiffusionWeighted",
        "nidm:EEG",
        "nidm:FlowWeighted",
        "nidm:T1Weighted",
        "nidm:T2Weighted",
    ],
)
def test_get_valid_available_image_modal(
    test_app, mock_successful_get, valid_available_image_modal, monkeypatch
):
    """Given a valid and available image modality, returns a 200 status code and a non-empty list of results."""

    monkeypatch.setattr(crud, "get", mock_successful_get)
    response = test_app.get(
        f"/query/?image_modal={valid_available_image_modal}"
    )
    assert response.status_code == 200
    assert response.json() != []


@pytest.mark.parametrize(
    "valid_unavailable_image_modal",
    ["nidm:Flair", "owl:sameAs", "bg:FlowWeighted", "snomed:something"],
)
def test_get_valid_unavailable_image_modal(
    test_app, valid_unavailable_image_modal, monkeypatch
):
    """Given a valid, pre-defined, and unavailable image modality, returns a 200 status code and an empty list of results."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return []

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get(
        f"/query/?image_modal={valid_unavailable_image_modal}"
    )
    assert response.status_code == 200
    assert response.json() == []


@pytest.mark.parametrize(
    "invalid_image_modal", ["2nim:EEG", "apple", "some_thing:cool"]
)
def test_get_invalid_image_modal(test_app, invalid_image_modal, monkeypatch):
    """Given an invalid image modality, returns a 422 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        return None

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get(f"/query/?image_modal={invalid_image_modal}")
    assert response.status_code == 422


@pytest.mark.parametrize(
    "undefined_prefix_image_modal",
    ["dbo:abstract", "sex:apple", "something:cool"],
)
def test_get_undefined_prefix_image_modal(
    test_app, undefined_prefix_image_modal, monkeypatch
):
    """Given a valid and undefined prefix image modality, returns a 500 status code."""

    async def mock_get(
        age_min,
        age_max,
        sex,
        diagnosis,
        is_control,
        min_num_sessions,
        image_modal,
    ):
        raise HTTPException(500)

    monkeypatch.setattr(crud, "get", mock_get)
    response = test_app.get(
        f"/query/?image_modal={undefined_prefix_image_modal}"
    )
    assert response.status_code == 500

1	"""Test API to query subjects from the Stardog graph who match user-specified criteria."""	1✔
2
3	import httpx	1✔
4	import pytest	1✔
5	from fastapi import HTTPException	1✔
6
7	from app.api import crud	1✔
8
9
10	@pytest.fixture	1✔
11	def test_data():	1✔
12	"""Create toy data for two subjects for testing."""
13	data = [	1✔
14	{
15	"number_session": "test1",
16	"modality": "test1",
17	"subject": "test1",
18	"sub_id": "test1",
19	"sex": "test1",
20	"diagnosis": "test1",
21	"dataset_name": "test1",
22	"dataset": "test1",
23	"age": "test1",
24	},
25	{
26	"number_session": "test2",
27	"modality": "test2",
28	"subject": "test2",
29	"sub_id": "test2",
30	"sex": "test2",
31	"diagnosis": "test2",
32	"dataset_name": "test2",
33	"dataset": "test2",
34	"age": "test2",
35	},
36	]
37	return data	1✔
38
39
40	@pytest.fixture	1✔
41	def mock_successful_get(test_data):	1✔
42	"""Mock get function that returns non-empty query results."""
43
44	async def mockreturn(	1✔
45	age_min,
46	age_max,
47	sex,
48	diagnosis,
49	is_control,
50	min_num_sessions,
51	image_modal,
52	):
53	return test_data	1✔
54
55	return mockreturn	1✔
56
57
58	def test_start_app_without_environment_vars_fails(test_app, monkeypatch):	1✔
59	"""Given non-existing USER and PASSWORD environment variables, raises an informative RuntimeError."""
60	monkeypatch.delenv("USER", raising=False)	1✔
61	monkeypatch.delenv("PASSWORD", raising=False)	1✔
62
63	with pytest.raises(RuntimeError) as e_info:	1✔
64	with test_app:	1✔
65	pass	×
66	assert (	1✔
67	"could not find the USER and / or PASSWORD environment variables"
68	in str(e_info.value)
69	)
70
71
72	def test_app_with_invalid_environment_vars(test_app, monkeypatch):	1✔
73	"""Given invalid environment variables, returns a 401 status code."""
74	monkeypatch.setenv("USER", "something")	1✔
75	monkeypatch.setenv("PASSWORD", "cool")	1✔
76
77	def mock_httpx_post(**kwargs):	1✔
78	return httpx.Response(status_code=401)	1✔
79
80	monkeypatch.setattr(httpx, "post", mock_httpx_post)	1✔
81	response = test_app.get("/query/")	1✔
82	assert response.status_code == 401	1✔
83
84
85	def test_get_all(test_app, mock_successful_get, monkeypatch):	1✔
86	"""Given no input for the sex parameter, returns a 200 status code and a non-empty list of results (should correspond to all subjects in graph)."""
87
88	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
89	response = test_app.get("/query/")	1✔
90	assert response.status_code == 200	1✔
91	assert response.json() != []	1✔
92
93
94	@pytest.mark.parametrize(	1✔
95	"valid_age_min, valid_age_max",
96	[(30.5, 60), (23, 23)],
97	)
98	def test_get_valid_age_range(	1✔
99	test_app, mock_successful_get, valid_age_min, valid_age_max, monkeypatch
100	):
101	"""Given a valid age range, returns a 200 status code and a non-empty list of results."""
102
103	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
104	response = test_app.get(	1✔
105	f"/query/?age_min={valid_age_min}&age_max={valid_age_max}"
106	)
107	assert response.status_code == 200	1✔
108	assert response.json() != []	1✔
109
110
111	@pytest.mark.parametrize(	1✔
112	"age_keyval",
113	["age_min=20.75", "age_max=50"],
114	)
115	def test_get_valid_age_single_bound(	1✔
116	test_app, mock_successful_get, age_keyval, monkeypatch
117	):
118	"""Given only a valid lower/upper age bound, returns a 200 status code and a non-empty list of results."""
119
120	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
121	response = test_app.get(f"/query/?{age_keyval}")	1✔
122	assert response.status_code == 200	1✔
123	assert response.json() != []	1✔
124
125
126	@pytest.mark.parametrize(	1✔
127	"invalid_age_min, invalid_age_max",
128	[
129	("forty", "fifty"),
130	(33, 21),
131	(-42.5, -40),
132	],
133	)
134	def test_get_invalid_age(	1✔
135	test_app, invalid_age_min, invalid_age_max, monkeypatch
136	):
137	"""Given an invalid age range, returns a 422 status code."""
138
139	async def mock_get(	1✔
140	age_min,
141	age_max,
142	sex,
143	diagnosis,
144	is_control,
145	min_num_sessions,
146	image_modal,
147	):
148	return None	×
149
150	monkeypatch.setattr(crud, "get", mock_get)	1✔
151	response = test_app.get(	1✔
152	f"/query/?age_min={invalid_age_min}&age_max={invalid_age_max}"
153	)
154	assert response.status_code == 422	1✔
155
156
157	@pytest.mark.parametrize("valid_sex", ["male", "female", "other"])	1✔
158	def test_get_valid_sex(test_app, mock_successful_get, valid_sex, monkeypatch):	1✔
159	"""Given a valid sex string, returns a 200 status code and a non-empty list of results."""
160
161	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
162	response = test_app.get(f"/query/?sex={valid_sex}")	1✔
163	assert response.status_code == 200	1✔
164	assert response.json() != []	1✔
165
166
167	def test_get_invalid_sex(test_app, monkeypatch):	1✔
168	"""Given an invalid sex string (i.e., anything other than ["male", "female", None]), returns a 422 status code."""
169
170	async def mock_get(	1✔
171	age_min,
172	age_max,
173	sex,
174	diagnosis,
175	is_control,
176	min_num_sessions,
177	image_modal,
178	):
179	return None	×
180
181	monkeypatch.setattr(crud, "get", mock_get)	1✔
182	response = test_app.get("/query/?sex=apple")	1✔
183	assert response.status_code == 422	1✔
184
185
186	@pytest.mark.parametrize(	1✔
187	"valid_diagnosis", ["snomed:35489007", "snomed:49049000"]
188	)
189	def test_get_valid_diagnosis(	1✔
190	test_app, mock_successful_get, valid_diagnosis, monkeypatch
191	):
192	"""Given a valid diagnosis, returns a 200 status code and a non-empty list of results."""
193
194	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
195	response = test_app.get(f"/query/?diagnosis={valid_diagnosis}")	1✔
196	assert response.status_code == 200	1✔
197	assert response.json() != []	1✔
198
199
200	@pytest.mark.parametrize(	1✔
201	"invalid_diagnosis", ["sn0med:35489007", "apple", ":123456"]
202	)
203	def test_get_invalid_diagnosis(test_app, invalid_diagnosis, monkeypatch):	1✔
204	"""Given an invalid diagnosis, returns a 422 status code."""
205
206	async def mock_get(	1✔
207	age_min,
208	age_max,
209	sex,
210	diagnosis,
211	is_control,
212	min_num_sessions,
213	image_modal,
214	):
215	return None	×
216
217	monkeypatch.setattr(crud, "get", mock_get)	1✔
218	response = test_app.get(f"/query/?diagnosis={invalid_diagnosis}")	1✔
219	assert response.status_code == 422	1✔
220
221
222	@pytest.mark.parametrize("valid_iscontrol", [True, False])	1✔
223	def test_get_valid_iscontrol(	1✔
224	test_app, mock_successful_get, valid_iscontrol, monkeypatch
225	):
226	"""Given a valid is_control value, returns a 200 status code and a non-empty list of results."""
227
228	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
229	response = test_app.get(f"/query/?is_control={valid_iscontrol}")	1✔
230	assert response.status_code == 200	1✔
231	assert response.json() != []	1✔
232
233
234	def test_get_invalid_iscontrol(test_app, monkeypatch):	1✔
235	"""Given a non-boolean is_control value, returns a 422 status code."""
236
237	async def mock_get(	1✔
238	age_min,
239	age_max,
240	sex,
241	diagnosis,
242	is_control,
243	min_num_sessions,
244	image_modal,
245	):
246	return None	×
247
248	monkeypatch.setattr(crud, "get", mock_get)	1✔
249	response = test_app.get("/query/?is_control=apple")	1✔
250	assert response.status_code == 422	1✔
251
252
253	def test_get_invalid_control_diagnosis_pair(test_app, monkeypatch):	1✔
254	"""Given a non-default diagnosis value and is_control value of True, returns a 422 status code."""
255
256	async def mock_get(	1✔
257	age_min,
258	age_max,
259	sex,
260	diagnosis,
261	is_control,
262	min_num_sessions,
263	image_modal,
264	):
265	return None	×
266
267	monkeypatch.setattr(crud, "get", mock_get)	1✔
268	response = test_app.get(	1✔
269	"/query/?diagnosis=snomed:35489007&is_control=True"
270	)
271	assert response.status_code == 422	1✔
272	assert (	1✔
273	"Subjects cannot both be healthy controls and have a diagnosis"
274	in response.text
275	)
276
277
278	@pytest.mark.parametrize("valid_min_num_sessions", [1, 2, 4, 7])	1✔
279	def test_get_valid_min_num_sessions(	1✔
280	test_app, mock_successful_get, valid_min_num_sessions, monkeypatch
281	):
282	"""Given a valid minimum number of imaging sessions, returns a 200 status code and a non-empty list of results."""
283
284	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
285	response = test_app.get(	1✔
286	f"/query/?min_num_sessions={valid_min_num_sessions}"
287	)
288	assert response.status_code == 200	1✔
289	assert response.json() != []	1✔
290
291
292	@pytest.mark.parametrize("invalid_min_num_sessions", [0, -3, "apple"])	1✔
293	def test_get_invalid_min_num_sessions(	1✔
294	test_app, invalid_min_num_sessions, monkeypatch
295	):
296	"""Given an invalid minimum number of imaging sessions, returns a 422 status code."""
297
298	async def mock_get(	1✔
299	age_min,
300	age_max,
301	sex,
302	diagnosis,
303	is_control,
304	min_num_sessions,
305	image_modal,
306	):
307	return None	×
308
309	monkeypatch.setattr(crud, "get", mock_get)	1✔
310	response = test_app.get(	1✔
311	f"/query/?min_num_sessions={invalid_min_num_sessions}"
312	)
313	response.status_code = 422	1✔
314
315
316	@pytest.mark.parametrize(	1✔
317	"valid_available_image_modal",
318	[
319	"nidm:DiffusionWeighted",
320	"nidm:EEG",
321	"nidm:FlowWeighted",
322	"nidm:T1Weighted",
323	"nidm:T2Weighted",
324	],
325	)
326	def test_get_valid_available_image_modal(	1✔
327	test_app, mock_successful_get, valid_available_image_modal, monkeypatch
328	):
329	"""Given a valid and available image modality, returns a 200 status code and a non-empty list of results."""
330
331	monkeypatch.setattr(crud, "get", mock_successful_get)	1✔
332	response = test_app.get(	1✔
333	f"/query/?image_modal={valid_available_image_modal}"
334	)
335	assert response.status_code == 200	1✔
336	assert response.json() != []	1✔
337
338
339	@pytest.mark.parametrize(	1✔
340	"valid_unavailable_image_modal",
341	["nidm:Flair", "owl:sameAs", "bg:FlowWeighted", "snomed:something"],
342	)
343	def test_get_valid_unavailable_image_modal(	1✔
344	test_app, valid_unavailable_image_modal, monkeypatch
345	):
346	"""Given a valid, pre-defined, and unavailable image modality, returns a 200 status code and an empty list of results."""
347
348	async def mock_get(	1✔
349	age_min,
350	age_max,
351	sex,
352	diagnosis,
353	is_control,
354	min_num_sessions,
355	image_modal,
356	):
357	return []	1✔
358
359	monkeypatch.setattr(crud, "get", mock_get)	1✔
360	response = test_app.get(	1✔
361	f"/query/?image_modal={valid_unavailable_image_modal}"
362	)
363	assert response.status_code == 200	1✔
364	assert response.json() == []	1✔
365
366
367	@pytest.mark.parametrize(	1✔
368	"invalid_image_modal", ["2nim:EEG", "apple", "some_thing:cool"]
369	)
370	def test_get_invalid_image_modal(test_app, invalid_image_modal, monkeypatch):	1✔
371	"""Given an invalid image modality, returns a 422 status code."""
372
373	async def mock_get(	1✔
374	age_min,
375	age_max,
376	sex,
377	diagnosis,
378	is_control,
379	min_num_sessions,
380	image_modal,
381	):
382	return None	×
383
384	monkeypatch.setattr(crud, "get", mock_get)	1✔
385	response = test_app.get(f"/query/?image_modal={invalid_image_modal}")	1✔
386	assert response.status_code == 422	1✔
387
388
389	@pytest.mark.parametrize(	1✔
390	"undefined_prefix_image_modal",
391	["dbo:abstract", "sex:apple", "something:cool"],
392	)
393	def test_get_undefined_prefix_image_modal(	1✔
394	test_app, undefined_prefix_image_modal, monkeypatch
395	):
396	"""Given a valid and undefined prefix image modality, returns a 500 status code."""
397
398	async def mock_get(	1✔
399	age_min,
400	age_max,
401	sex,
402	diagnosis,
403	is_control,
404	min_num_sessions,
405	image_modal,
406	):
407	raise HTTPException(500)	1✔
408
409	monkeypatch.setattr(crud, "get", mock_get)	1✔
410	response = test_app.get(	1✔
411	f"/query/?image_modal={undefined_prefix_image_modal}"
412	)
413	assert response.status_code == 500	1✔

neurobagel / api / 3876649721

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous