Coverage for tests/test_pephubclient.py: 100%
154 statements
« prev ^ index » next coverage.py v7.15.3, created at 2026-08-04 18:15 +0000
« prev ^ index » next coverage.py v7.15.3, created at 2026-08-04 18:15 +0000
1import os
2from unittest.mock import Mock
4import pytest
6from pephubclient.constants import CachedToken
7from pephubclient.exceptions import ResponseError
8from pephubclient.pephubclient import PEPHubClient
9from pephubclient.helpers import is_registry_path
11SAMPLE_PEP = os.path.join(
12 os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
13 "tests",
14 "data",
15 "sample_pep",
16 "subsamp_config.yaml",
17)
20class TestSmoke:
21 def test_login(self, mocker, device_code_return, test_jwt):
22 """
23 Test if device login request was sent to pephub
24 """
25 requests_mock = mocker.patch(
26 "requests.request",
27 return_value=Mock(content=device_code_return, status_code=200),
28 )
29 pephub_response_mock = mocker.patch(
30 "pephubclient.pephub_oauth.pephub_oauth.PEPHubAuth._handle_pephub_response",
31 return_value=device_code_return,
32 )
33 pephub_exchange_code_mock = mocker.patch(
34 "pephubclient.pephub_oauth.pephub_oauth.PEPHubAuth._exchange_device_code_on_token",
35 return_value=test_jwt,
36 )
38 pathlib_mock = mocker.patch(
39 "pephubclient.files_manager.FilesManager.save_token_data"
40 )
42 PEPHubClient().login()
44 assert requests_mock.called
45 assert pephub_response_mock.called
46 assert pephub_exchange_code_mock.called
47 assert pathlib_mock.called
49 def test_login_with_token_skips_device_flow(self, mocker, test_jwt):
50 """Providing a token registers it directly without the device flow."""
51 login_mock = mocker.patch(
52 "pephubclient.pephub_oauth.pephub_oauth.PEPHubAuth.login_to_pephub"
53 )
54 save_mock = mocker.patch(
55 "pephubclient.files_manager.FilesManager.save_token_data"
56 )
58 PEPHubClient().login(token=test_jwt, url="https://example.org/")
60 assert not login_mock.called
61 saved = save_mock.call_args.args[1]
62 assert saved.token == test_jwt
63 assert saved.base_url == "https://example.org/"
65 def test_login_url_passed_to_device_flow(self, mocker, test_jwt):
66 """Without a token, the url is forwarded to the device-code flow."""
67 login_mock = mocker.patch(
68 "pephubclient.pephub_oauth.pephub_oauth.PEPHubAuth.login_to_pephub",
69 return_value=test_jwt,
70 )
71 mocker.patch("pephubclient.files_manager.FilesManager.save_token_data")
73 PEPHubClient().login(url="https://example.org/")
75 login_mock.assert_called_once_with(base_url="https://example.org/")
77 def test_logout(self, mocker):
78 os_remove_mock = mocker.patch("os.remove")
79 PEPHubClient().logout()
81 assert os_remove_mock.called
83 def test_pull(self, mocker, test_jwt, test_raw_pep_return):
84 jwt_mock = mocker.patch(
85 "pephubclient.files_manager.FilesManager.load_token_data",
86 return_value=CachedToken(token=test_jwt),
87 )
88 requests_mock = mocker.patch(
89 "requests.request",
90 return_value=Mock(content="some return", status_code=200),
91 )
92 mocker.patch(
93 "pephubclient.helpers.RequestManager.decode_response",
94 return_value=test_raw_pep_return,
95 )
96 save_yaml_mock = mocker.patch(
97 "pephubclient.files_manager.FilesManager.save_yaml"
98 )
99 save_sample_mock = mocker.patch(
100 "pephubclient.files_manager.FilesManager.save_pandas"
101 )
102 mocker.patch("pephubclient.files_manager.FilesManager.create_project_folder")
104 PEPHubClient().pull("some/project")
106 assert jwt_mock.called
107 assert requests_mock.called
108 assert save_yaml_mock.called
109 assert save_sample_mock.called
111 @pytest.mark.parametrize(
112 "status_code, expected_error_message",
113 [
114 (
115 404,
116 "File does not exist, or you are unauthorized.",
117 ),
118 (
119 500,
120 "Internal server error. Unexpected return value. Error: 500",
121 ),
122 ],
123 )
124 def test_pull_with_pephub_error_response(
125 self, mocker, test_jwt, status_code, expected_error_message
126 ):
127 mocker.patch(
128 "pephubclient.files_manager.FilesManager.load_token_data",
129 return_value=CachedToken(token=test_jwt),
130 )
131 mocker.patch(
132 "requests.request",
133 return_value=Mock(
134 content=b'{"detail": "Some error message"}', status_code=status_code
135 ),
136 )
138 with pytest.raises(ResponseError) as e:
139 PEPHubClient().pull("some/project")
141 assert e.value.message == expected_error_message
143 def test_push(self, mocker, test_jwt):
144 requests_mock = mocker.patch(
145 "requests.request", return_value=Mock(status_code=202)
146 )
148 PEPHubClient().push(
149 SAMPLE_PEP,
150 namespace="s_name",
151 name="name",
152 )
154 assert requests_mock.called
156 @pytest.mark.parametrize(
157 "status_code, expected_error_message",
158 [
159 (
160 409,
161 "Project already exists. Set force to overwrite project.",
162 ),
163 (
164 401,
165 "Unauthorized! Failure in uploading project.",
166 ),
167 (233, "Unexpected Response Error."),
168 ],
169 )
170 def test_push_with_pephub_error_response(
171 self, mocker, status_code, expected_error_message
172 ):
173 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
174 with pytest.raises(ResponseError, match=expected_error_message):
175 PEPHubClient().push(
176 SAMPLE_PEP,
177 namespace="s_name",
178 name="name",
179 )
181 def test_search_prj(self, mocker):
182 return_value = {
183 "count": 1,
184 "limit": 100,
185 "offset": 0,
186 "results": [
187 {
188 "namespace": "namespace1",
189 "name": "basic",
190 "tag": "default",
191 "is_private": False,
192 "number_of_samples": 2,
193 "description": "None",
194 "last_update_date": "2023-08-27 19:07:31.552861+00:00",
195 "submission_date": "2023-08-27 19:07:31.552858+00:00",
196 "digest": "08cbcdbf4974fc84bee824c562b324b5",
197 "pep_schema": "random_schema_name",
198 "pop": False,
199 "stars_number": 0,
200 "forked_from": None,
201 }
202 ],
203 "session_info": None,
204 "can_edit": False,
205 }
206 mocker.patch(
207 "requests.request",
208 return_value=Mock(content=return_value, status_code=200),
209 )
210 mocker.patch(
211 "pephubclient.helpers.RequestManager.decode_response",
212 return_value=return_value,
213 )
215 return_value = PEPHubClient().find_project(namespace="namespace1")
216 assert return_value.count == 1
217 assert len(return_value.results) == 1
220class TestHelpers:
221 @pytest.mark.parametrize(
222 "input_str, expected_output",
223 [
224 (
225 "databio/pep:default",
226 True,
227 ),
228 (
229 "pephub.databio.org::databio/pep:default",
230 True,
231 ),
232 (
233 "pephub.databio.org://databio/pep:default",
234 True,
235 ),
236 (
237 "databio/pep",
238 True,
239 ),
240 (
241 "databio/pep/default",
242 False,
243 ),
244 (
245 "some/random/path/to.yaml",
246 False,
247 ),
248 (
249 "path_to.csv",
250 False,
251 ),
252 (
253 "this/is/path/to.csv",
254 False,
255 ),
256 ],
257 )
258 def test_is_registry_path(self, input_str, expected_output):
259 assert is_registry_path(input_str) is expected_output
262class TestSamples:
263 def test_get(self, mocker):
264 return_value = {
265 "genome": "phc_test1",
266 "sample_type": "phc_test",
267 "sample_name": "gg1",
268 }
269 mocker.patch(
270 "requests.request",
271 return_value=Mock(content=return_value, status_code=200),
272 )
273 mocker.patch(
274 "pephubclient.helpers.RequestManager.decode_response",
275 return_value=return_value,
276 )
277 return_value = PEPHubClient().sample.get(
278 "test_namespace",
279 "taest_name",
280 "default",
281 "gg1",
282 )
283 assert return_value == return_value
285 @pytest.mark.parametrize(
286 "status_code, expected_error_message",
287 [
288 (
289 404,
290 "Sample does not exist.",
291 ),
292 (
293 500,
294 "Internal server error. Unexpected return value.",
295 ),
296 (
297 403,
298 "Unexpected return value. Error: 403",
299 ),
300 ],
301 )
302 def test_sample_get_with_pephub_error_response(
303 self, mocker, status_code, expected_error_message
304 ):
305 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
306 with pytest.raises(ResponseError, match=expected_error_message):
307 PEPHubClient().sample.get(
308 "test_namespace",
309 "taest_name",
310 "default",
311 "gg1",
312 )
314 @pytest.mark.parametrize(
315 "prj_dict",
316 [
317 {"genome": "phc_test1", "sample_type": "phc_test", "sample_name": "gg1"},
318 {"genome": "phc_test1", "sample_type": "phc_test"},
319 ],
320 )
321 def test_create(self, mocker, prj_dict):
322 return_value = prj_dict
323 mocker_obj = mocker.patch(
324 "requests.request",
325 return_value=Mock(content=return_value, status_code=202),
326 )
328 PEPHubClient().sample.create(
329 "test_namespace",
330 "taest_name",
331 "default",
332 "gg1",
333 sample_dict=return_value,
334 )
335 assert mocker_obj.called
337 @pytest.mark.parametrize(
338 "status_code, expected_error_message",
339 [
340 (
341 404,
342 "does not exist.",
343 ),
344 (
345 409,
346 "already exists. Set overwrite to True to overwrite sample.",
347 ),
348 (
349 500,
350 "Unexpected return value.",
351 ),
352 ],
353 )
354 def test_sample_create_with_pephub_error_response(
355 self, mocker, status_code, expected_error_message
356 ):
357 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
358 with pytest.raises(ResponseError, match=expected_error_message):
359 PEPHubClient().sample.create(
360 "test_namespace",
361 "taest_name",
362 "default",
363 "gg1",
364 sample_dict={
365 "genome": "phc_test1",
366 "sample_type": "phc_test",
367 "sample_name": "gg1",
368 },
369 )
371 def test_delete(self, mocker):
372 mocker_obj = mocker.patch(
373 "requests.request",
374 return_value=Mock(status_code=202),
375 )
377 PEPHubClient().sample.remove(
378 "test_namespace",
379 "taest_name",
380 "default",
381 "gg1",
382 )
383 assert mocker_obj.called
385 @pytest.mark.parametrize(
386 "status_code, expected_error_message",
387 [
388 (
389 404,
390 "does not exist.",
391 ),
392 (
393 500,
394 "Unexpected return value.",
395 ),
396 ],
397 )
398 def test_sample_delete_with_pephub_error_response(
399 self, mocker, status_code, expected_error_message
400 ):
401 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
402 with pytest.raises(ResponseError, match=expected_error_message):
403 PEPHubClient().sample.remove(
404 "test_namespace",
405 "taest_name",
406 "default",
407 "gg1",
408 )
410 def test_update(self, mocker):
411 mocker_obj = mocker.patch(
412 "requests.request",
413 return_value=Mock(status_code=202),
414 )
416 PEPHubClient().sample.update(
417 "test_namespace",
418 "taest_name",
419 "default",
420 "gg1",
421 sample_dict={
422 "genome": "phc_test1",
423 "sample_type": "phc_test",
424 "new_col": "column",
425 },
426 )
427 assert mocker_obj.called
429 @pytest.mark.parametrize(
430 "status_code, expected_error_message",
431 [
432 (
433 404,
434 "does not exist.",
435 ),
436 (
437 500,
438 "Unexpected return value.",
439 ),
440 ],
441 )
442 def test_sample_update_with_pephub_error_response(
443 self, mocker, status_code, expected_error_message
444 ):
445 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
446 with pytest.raises(ResponseError, match=expected_error_message):
447 PEPHubClient().sample.update(
448 "test_namespace",
449 "taest_name",
450 "default",
451 "gg1",
452 sample_dict={
453 "genome": "phc_test1",
454 "sample_type": "phc_test",
455 "new_col": "column",
456 },
457 )
460class TestViews:
461 def test_get(self, mocker, test_raw_pep_return):
462 return_value = test_raw_pep_return
463 mocker.patch(
464 "requests.request",
465 return_value=Mock(content=return_value, status_code=200),
466 )
467 mocker.patch(
468 "pephubclient.helpers.RequestManager.decode_response",
469 return_value=return_value,
470 )
472 return_value = PEPHubClient().view.get(
473 "test_namespace",
474 "taest_name",
475 "default",
476 "gg1",
477 )
478 assert return_value == return_value
480 @pytest.mark.parametrize(
481 "status_code, expected_error_message",
482 [
483 (
484 404,
485 "does not exist.",
486 ),
487 (
488 500,
489 "Internal server error.",
490 ),
491 ],
492 )
493 def test_view_get_with_pephub_error_response(
494 self, mocker, status_code, expected_error_message
495 ):
496 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
497 with pytest.raises(ResponseError, match=expected_error_message):
498 PEPHubClient().view.get(
499 "test_namespace",
500 "taest_name",
501 "default",
502 "gg1",
503 )
505 def test_create(self, mocker):
506 mocker_obj = mocker.patch(
507 "requests.request",
508 return_value=Mock(status_code=202),
509 )
511 PEPHubClient().view.create(
512 "test_namespace",
513 "taest_name",
514 "default",
515 "gg1",
516 sample_list=["sample1", "sample2"],
517 )
518 assert mocker_obj.called
520 @pytest.mark.parametrize(
521 "status_code, expected_error_message",
522 [
523 (
524 404,
525 "does not exist.",
526 ),
527 (
528 409,
529 "already exists in the project.",
530 ),
531 ],
532 )
533 def test_view_create_with_pephub_error_response(
534 self, mocker, status_code, expected_error_message
535 ):
536 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
537 with pytest.raises(ResponseError, match=expected_error_message):
538 PEPHubClient().view.create(
539 "test_namespace",
540 "taest_name",
541 "default",
542 "gg1",
543 sample_list=["sample1", "sample2"],
544 )
546 def test_delete(self, mocker):
547 mocker_obj = mocker.patch(
548 "requests.request",
549 return_value=Mock(status_code=202),
550 )
552 PEPHubClient().view.delete(
553 "test_namespace",
554 "taest_name",
555 "default",
556 "gg1",
557 )
558 assert mocker_obj.called
560 @pytest.mark.parametrize(
561 "status_code, expected_error_message",
562 [
563 (
564 404,
565 "does not exist.",
566 ),
567 (
568 401,
569 "You are unauthorized to delete this view.",
570 ),
571 ],
572 )
573 def test_view_delete_with_pephub_error_response(
574 self, mocker, status_code, expected_error_message
575 ):
576 mocker.patch("requests.request", return_value=Mock(status_code=status_code))
577 with pytest.raises(ResponseError, match=expected_error_message):
578 PEPHubClient().view.delete(
579 "test_namespace",
580 "taest_name",
581 "default",
582 "gg1",
583 )
585 def test_add_sample(self, mocker):
586 mocker_obj = mocker.patch(
587 "requests.request",
588 return_value=Mock(status_code=202),
589 )
591 PEPHubClient().view.add_sample(
592 "test_namespace",
593 "taest_name",
594 "default",
595 "gg1",
596 "sample1",
597 )
598 assert mocker_obj.called
600 def test_delete_sample(self, mocker):
601 mocker_obj = mocker.patch(
602 "requests.request",
603 return_value=Mock(status_code=202),
604 )
606 PEPHubClient().view.remove_sample(
607 "test_namespace",
608 "taest_name",
609 "default",
610 "gg1",
611 "sample1",
612 )
613 assert mocker_obj.called
616###
619# test add sample:
620# 1. add correct 202
621# 2. add existing 409
622# 3. add with sample_name
623# 4. add without sample_name
624# 5. add with overwrite
625# 6. add to unexisting project 404
627# delete sample:
628# 1. delete existing 202
629# 2. delete unexisting 404
631# get sample:
632# 1. get existing 200
633# 2. get unexisting 404
634# 3. get with raw 200
635# 4. get from unexisting project 404
637# update sample:
638# 1. update existing 202
639# 2. update unexisting sample 404
640# 3. update unexisting project 404