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

1import os 

2from unittest.mock import Mock 

3 

4import pytest 

5 

6from pephubclient.constants import CachedToken 

7from pephubclient.exceptions import ResponseError 

8from pephubclient.pephubclient import PEPHubClient 

9from pephubclient.helpers import is_registry_path 

10 

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) 

18 

19 

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 ) 

37 

38 pathlib_mock = mocker.patch( 

39 "pephubclient.files_manager.FilesManager.save_token_data" 

40 ) 

41 

42 PEPHubClient().login() 

43 

44 assert requests_mock.called 

45 assert pephub_response_mock.called 

46 assert pephub_exchange_code_mock.called 

47 assert pathlib_mock.called 

48 

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 ) 

57 

58 PEPHubClient().login(token=test_jwt, url="https://example.org/") 

59 

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/" 

64 

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") 

72 

73 PEPHubClient().login(url="https://example.org/") 

74 

75 login_mock.assert_called_once_with(base_url="https://example.org/") 

76 

77 def test_logout(self, mocker): 

78 os_remove_mock = mocker.patch("os.remove") 

79 PEPHubClient().logout() 

80 

81 assert os_remove_mock.called 

82 

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") 

103 

104 PEPHubClient().pull("some/project") 

105 

106 assert jwt_mock.called 

107 assert requests_mock.called 

108 assert save_yaml_mock.called 

109 assert save_sample_mock.called 

110 

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 ) 

137 

138 with pytest.raises(ResponseError) as e: 

139 PEPHubClient().pull("some/project") 

140 

141 assert e.value.message == expected_error_message 

142 

143 def test_push(self, mocker, test_jwt): 

144 requests_mock = mocker.patch( 

145 "requests.request", return_value=Mock(status_code=202) 

146 ) 

147 

148 PEPHubClient().push( 

149 SAMPLE_PEP, 

150 namespace="s_name", 

151 name="name", 

152 ) 

153 

154 assert requests_mock.called 

155 

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 ) 

180 

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 ) 

214 

215 return_value = PEPHubClient().find_project(namespace="namespace1") 

216 assert return_value.count == 1 

217 assert len(return_value.results) == 1 

218 

219 

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 

260 

261 

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 

284 

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 ) 

313 

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 ) 

327 

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 

336 

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 ) 

370 

371 def test_delete(self, mocker): 

372 mocker_obj = mocker.patch( 

373 "requests.request", 

374 return_value=Mock(status_code=202), 

375 ) 

376 

377 PEPHubClient().sample.remove( 

378 "test_namespace", 

379 "taest_name", 

380 "default", 

381 "gg1", 

382 ) 

383 assert mocker_obj.called 

384 

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 ) 

409 

410 def test_update(self, mocker): 

411 mocker_obj = mocker.patch( 

412 "requests.request", 

413 return_value=Mock(status_code=202), 

414 ) 

415 

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 

428 

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 ) 

458 

459 

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 ) 

471 

472 return_value = PEPHubClient().view.get( 

473 "test_namespace", 

474 "taest_name", 

475 "default", 

476 "gg1", 

477 ) 

478 assert return_value == return_value 

479 

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 ) 

504 

505 def test_create(self, mocker): 

506 mocker_obj = mocker.patch( 

507 "requests.request", 

508 return_value=Mock(status_code=202), 

509 ) 

510 

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 

519 

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 ) 

545 

546 def test_delete(self, mocker): 

547 mocker_obj = mocker.patch( 

548 "requests.request", 

549 return_value=Mock(status_code=202), 

550 ) 

551 

552 PEPHubClient().view.delete( 

553 "test_namespace", 

554 "taest_name", 

555 "default", 

556 "gg1", 

557 ) 

558 assert mocker_obj.called 

559 

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 ) 

584 

585 def test_add_sample(self, mocker): 

586 mocker_obj = mocker.patch( 

587 "requests.request", 

588 return_value=Mock(status_code=202), 

589 ) 

590 

591 PEPHubClient().view.add_sample( 

592 "test_namespace", 

593 "taest_name", 

594 "default", 

595 "gg1", 

596 "sample1", 

597 ) 

598 assert mocker_obj.called 

599 

600 def test_delete_sample(self, mocker): 

601 mocker_obj = mocker.patch( 

602 "requests.request", 

603 return_value=Mock(status_code=202), 

604 ) 

605 

606 PEPHubClient().view.remove_sample( 

607 "test_namespace", 

608 "taest_name", 

609 "default", 

610 "gg1", 

611 "sample1", 

612 ) 

613 assert mocker_obj.called 

614 

615 

616### 

617 

618 

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 

626 

627# delete sample: 

628# 1. delete existing 202 

629# 2. delete unexisting 404 

630 

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 

636 

637# update sample: 

638# 1. update existing 202 

639# 2. update unexisting sample 404 

640# 3. update unexisting project 404