Coverage for tests/route_tests/test_user.py: 99%

1"""Tests for the user routes.""" 

2 

3# pylint: disable=redefined-outer-name 

4# flake8: noqa: F811 

5 

6import os 

7import sys 

8import uuid 

9from unittest.mock import patch 

10from passlib.hash import pbkdf2_sha512 

11import pytest 

12from dotenv import load_dotenv 

13 

14# Add the root directory to the Python path 

15sys.path.append( 

16 os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) 

17) 

18 

19from core import shared 

20from core.database_mongo_manager import DatabaseMongoManager 

21 

22os.environ["IS_TEST"] = "True" 

23 

24load_dotenv() 

25 

26 

27@pytest.fixture() 

28def client(): 

29 """Fixture to create a test client.""" 

30 from ...app import app # pylint: disable=import-outside-toplevel 

31 

32 app.config["TESTING"] = True 

33 return app.test_client() 

34 

35 

36@pytest.fixture() 

37def database(): 

38 """Fixture to create a test database.""" 

39 

40 database = DatabaseMongoManager( 

41 shared.getenv("MONGO_URI"), shared.getenv("MONGO_DB_TEST", "cs3528_testing") 

42 ) 

43 deadlines = database.get_all("deadline") 

44 database.delete_all("deadline") 

45 yield database 

46 

47 database.delete_all("deadline") 

48 for deadline in deadlines: 

49 database.insert("deadline", deadline) 

50 

51 # Cleanup code 

52 database.connection.close() 

53 

54 

55@pytest.fixture() 

56def user_logged_in_client(client, database: DatabaseMongoManager): 

57 """Fixture to login a user.""" 

58 database.add_table("users") 

59 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

60 

61 user = { 

62 "_id": uuid.uuid4().hex, 

63 "name": "dummy", 

64 "email": "dummy@dummy.com", 

65 "password": pbkdf2_sha512.hash("dummy"), 

66 } 

67 

68 database.insert("users", user) 

69 

70 url = "/user/login" 

71 client.post( 

72 url, 

73 data={ 

74 "email": "dummy@dummy.com", 

75 "password": "dummy", 

76 }, 

77 content_type="application/x-www-form-urlencoded", 

78 ) 

79 

80 yield client 

81 

82 # Cleanup code 

83 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

84 

85 

86@pytest.fixture() 

87def superuser_logged_in_client(client, database: DatabaseMongoManager): 

88 """Fixture to login a superuser.""" 

89 database.add_table("users") 

90 

91 superuser_email = shared.getenv("SUPERUSER_EMAIL") 

92 superuser_password = shared.getenv("SUPERUSER_PASSWORD") 

93 

94 url = "/user/login" 

95 

96 client.post( 

97 url, 

98 data={ 

99 "email": superuser_email, 

100 "password": superuser_password, 

101 }, 

102 content_type="application/x-www-form-urlencoded", 

103 ) 

104 

105 yield client 

106 

107 

108def test_upload_student_page(user_logged_in_client): 

109 """Test upload student page.""" 

110 url = "/students/upload" 

111 

112 response = user_logged_in_client.get(url) 

113 assert response.status_code == 200 

114 

115 

116def test_add_employer_page(user_logged_in_client): 

117 """Test add employer page.""" 

118 url = "/employers/add_employer" 

119 

120 response = user_logged_in_client.get(url) 

121 assert response.status_code == 200 

122 

123 

124def test_change_deadline_page(user_logged_in_client): 

125 """Test change deadline page.""" 

126 url = "/user/deadline" 

127 

128 response = user_logged_in_client.get(url) 

129 assert response.status_code == 200 

130 

131 

132def test_search_student_page(user_logged_in_client): 

133 """Test search student page.""" 

134 url = "/students/search" 

135 

136 response = user_logged_in_client.get(url) 

137 assert response.status_code == 200 

138 

139 

140def test_add_skill_page(user_logged_in_client): 

141 """Test add skill page.""" 

142 url = "/skills/add_skill" 

143 

144 response = user_logged_in_client.get(url) 

145 assert response.status_code == 200 

146 

147 

148def test_add_course_module_page(user_logged_in_client): 

149 """Test add course module page.""" 

150 url = "/course_modules/add_module" 

151 

152 response = user_logged_in_client.get(url) 

153 assert response.status_code == 200 

154 

155 

156def test_add_course_page(user_logged_in_client): 

157 """Test add course page.""" 

158 url = "/courses/add_course" 

159 

160 response = user_logged_in_client.get(url) 

161 assert response.status_code == 200 

162 

163 

164def test_search_employer_page(user_logged_in_client): 

165 """Test search employer page.""" 

166 url = "/employers/search" 

167 

168 response = user_logged_in_client.get(url) 

169 assert response.status_code == 200 

170 

171 

172def test_matching_page(user_logged_in_client): 

173 """Test matching page.""" 

174 url = "/user/matching" 

175 

176 response = user_logged_in_client.get(url) 

177 assert response.status_code == 200 

178 

179 

180def test_problem_page(user_logged_in_client): 

181 """Test problem page.""" 

182 url = "/user/problem" 

183 

184 response = user_logged_in_client.get(url) 

185 assert response.status_code == 200 

186 

187 

188def test_search_opportunity_page(user_logged_in_client): 

189 """Test search opportunity page.""" 

190 url = "/opportunities/search" 

191 

192 response = user_logged_in_client.get(url) 

193 assert response.status_code == 200 

194 

195 

196def test_register_page(superuser_logged_in_client): 

197 """Test register page.""" 

198 url = "/user/register" 

199 

200 response = superuser_logged_in_client.get(url) 

201 assert response.status_code == 200 

202 

203 

204def test_register_user(superuser_logged_in_client, database): 

205 """Test register user.""" 

206 url = "/user/register" 

207 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

208 

209 response = superuser_logged_in_client.post( 

210 url, 

211 data={ 

212 "name": "dummy", 

213 "email": "dummy@dummy.com", 

214 "password": "dummy", 

215 "confirm_password": "dummy", 

216 }, 

217 content_type="application/x-www-form-urlencoded", 

218 ) 

219 

220 assert response.status_code == 201 

221 assert database.get_by_email("users", "dummy@dummy.com") is not None 

222 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

223 

224 

225def test_register_user_password_mismatch(superuser_logged_in_client, database): 

226 """Test register user.""" 

227 url = "/user/register" 

228 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

229 

230 response = superuser_logged_in_client.post( 

231 url, 

232 data={ 

233 "name": "dummy", 

234 "email": "dummy@dummy.com", 

235 "password": "dummy", 

236 "confirm_password": "jsdkcjnjkd", 

237 }, 

238 content_type="application/x-www-form-urlencoded", 

239 ) 

240 

241 assert response.status_code == 400 

242 assert database.get_by_email("users", "dummy@dummy.com") is None 

243 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

244 

245 

246def test_email_already_in_use(superuser_logged_in_client, database): 

247 """Test register user.""" 

248 url = "/user/register" 

249 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

250 

251 user = { 

252 "_id": uuid.uuid4().hex, 

253 "name": "dummy", 

254 "email": "dummy@dummy.com", 

255 "password": pbkdf2_sha512.hash("dummy"), 

256 } 

257 

258 database.insert("users", user) 

259 

260 response = superuser_logged_in_client.post( 

261 url, 

262 data={ 

263 "name": "dummy2", 

264 "email": "dummy@dummy.com", 

265 "password": "dummy2", 

266 "confirm_password": "dummy2", 

267 }, 

268 content_type="application/x-www-form-urlencoded", 

269 ) 

270 

271 assert response.status_code == 400 

272 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

273 

274 

275def test_deadline_change(user_logged_in_client, database): 

276 """Test deadline change.""" 

277 url = "/user/deadline" 

278 

279 deadlines = database.get_all("deadline") 

280 if deadlines: 

281 database.delete_all("deadline") 

282 

283 database.insert("deadline", {"type": 0, "deadline": "2022-10-10"}) 

284 database.insert("deadline", {"type": 1, "deadline": "2022-10-12"}) 

285 database.insert("deadline", {"type": 2, "deadline": "2022-10-15"}) 

286 

287 response = user_logged_in_client.post( 

288 url, 

289 data={ 

290 "details_deadline": "2022-10-11", 

291 "student_ranking_deadline": "2022-10-14", 

292 "opportunities_ranking_deadline": "2022-10-18", 

293 }, 

294 content_type="application/x-www-form-urlencoded", 

295 ) 

296 

297 assert response.status_code == 200 

298 assert response.json["message"] == "All deadlines updated successfully" 

299 assert database.get_one_by_field("deadline", "type", 0)["deadline"] == "2022-10-11" 

300 assert database.get_one_by_field("deadline", "type", 1)["deadline"] == "2022-10-14" 

301 assert database.get_one_by_field("deadline", "type", 2)["deadline"] == "2022-10-18" 

302 

303 

304def test_update_user(superuser_logged_in_client, database): 

305 """Test update user.""" 

306 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

307 database.delete_all_by_field("users", "email", "dummy_updated@dummy.com") 

308 user = { 

309 "_id": uuid.uuid4().hex, 

310 "name": "dummy", 

311 "email": "dummy@dummy.com", 

312 "password": pbkdf2_sha512.hash("dummy"), 

313 } 

314 

315 database.insert("users", user) 

316 

317 url = f"/user/update?uuid={user['_id']}" 

318 response = superuser_logged_in_client.post( 

319 url, 

320 data={ 

321 "name": "dummy_updated", 

322 "email": "dummy_updated@dummy.com", 

323 }, 

324 content_type="application/x-www-form-urlencoded", 

325 ) 

326 

327 assert response.status_code == 200 

328 updated_user = database.get_by_email("users", "dummy_updated@dummy.com") 

329 assert updated_user is not None 

330 assert updated_user["name"] == "dummy_updated" 

331 assert updated_user["email"] == "dummy_updated@dummy.com" 

332 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

333 database.delete_all_by_field("users", "email", "dummy_updated@dummy.com") 

334 

335 

336def test_update_user_not_found(superuser_logged_in_client): 

337 """Test update user not found.""" 

338 url = "/user/update" 

339 non_existent_uuid = uuid.uuid4().hex 

340 

341 response = superuser_logged_in_client.post( 

342 url, 

343 data={ 

344 "uuid": non_existent_uuid, 

345 "name": "non_existent_user", 

346 "email": "non_existent@dummy.com", 

347 }, 

348 content_type="application/x-www-form-urlencoded", 

349 ) 

350 

351 assert response.status_code == 404 

352 

353 

354def test_update_user_get_request(superuser_logged_in_client, database): 

355 """Test update user GET request.""" 

356 url = "/user/update" 

357 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

358 

359 user = { 

360 "_id": uuid.uuid4().hex, 

361 "name": "dummy", 

362 "email": "dummy@dummy.com", 

363 "password": pbkdf2_sha512.hash("dummy"), 

364 } 

365 

366 database.insert("users", user) 

367 

368 response = superuser_logged_in_client.get(url, query_string={"uuid": user["_id"]}) 

369 

370 assert response.status_code == 200 

371 assert b"Update User" in response.data 

372 assert b"dummy" in response.data 

373 assert b"dummy@dummy.com" in response.data 

374 

375 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

376 

377 

378def test_login_user(client, database): 

379 """Test login user.""" 

380 database.add_table("users") 

381 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

382 

383 user = { 

384 "_id": uuid.uuid4().hex, 

385 "name": "dummy", 

386 "email": "dummy@dummy.com", 

387 "password": pbkdf2_sha512.hash("dummy"), 

388 } 

389 

390 database.insert("users", user) 

391 

392 url = "/user/login" 

393 response = client.post( 

394 url, 

395 data={ 

396 "email": "dummy@dummy.com", 

397 "password": "dummy", 

398 }, 

399 content_type="application/x-www-form-urlencoded", 

400 ) 

401 

402 assert response.status_code == 200 

403 

404 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

405 

406 

407def test_login_user_invalid_password(client, database): 

408 """Test login user with invalid password.""" 

409 database.add_table("users") 

410 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

411 

412 user = { 

413 "_id": uuid.uuid4().hex, 

414 "name": "dummy", 

415 "email": "dummy@dummy.com", 

416 "password": pbkdf2_sha512.hash("dummy"), 

417 } 

418 

419 database.insert("users", user) 

420 

421 url = "/user/login" 

422 response = client.post( 

423 url, 

424 data={ 

425 "email": "dummy@dummy.com", 

426 "password": "wrongpassword", 

427 }, 

428 content_type="application/x-www-form-urlencoded", 

429 ) 

430 

431 assert response.status_code == 401 

432 

433 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

434 

435 

436def test_login_user_missing_fields(client): 

437 """Test login user with missing fields.""" 

438 url = "/user/login" 

439 response = client.post( 

440 url, 

441 data={ 

442 "email": "dummy@dummy.com", 

443 }, 

444 content_type="application/x-www-form-urlencoded", 

445 ) 

446 

447 assert response.status_code == 400 

448 

449 url = "/user/login" 

450 response = client.post( 

451 url, 

452 data={ 

453 "password": "dummy", 

454 }, 

455 content_type="application/x-www-form-urlencoded", 

456 ) 

457 

458 assert response.status_code == 400 

459 

460 url = "/user/login" 

461 response = client.post( 

462 url, 

463 data={}, 

464 content_type="application/x-www-form-urlencoded", 

465 ) 

466 

467 assert response.status_code == 400 

468 

469 

470def test_login_superuser(client): 

471 """Test login superuser.""" 

472 url = "/user/login" 

473 response = client.post( 

474 url, 

475 data={ 

476 "email": shared.getenv("SUPERUSER_EMAIL"), 

477 "password": shared.getenv("SUPERUSER_PASSWORD"), 

478 }, 

479 content_type="application/x-www-form-urlencoded", 

480 ) 

481 

482 assert response.status_code == 200 

483 

484 

485def test_login_already_login(user_logged_in_client): 

486 """Test login already login.""" 

487 url = "/user/login" 

488 response = user_logged_in_client.get(url) 

489 

490 assert response.status_code == 200 

491 

492 

493def test_get_login_page(client): 

494 """Test get login page.""" 

495 url = "/user/login" 

496 response = client.get(url) 

497 

498 assert response.status_code == 200 

499 

500 

501def test_delete_user(superuser_logged_in_client, database): 

502 """Test delete user.""" 

503 url = "/user/delete" 

504 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

505 

506 user = { 

507 "_id": uuid.uuid4().hex, 

508 "name": "dummy", 

509 "email": "dummy@dummy.com", 

510 "password": pbkdf2_sha512.hash("dummy"), 

511 } 

512 

513 database.insert("users", user) 

514 

515 response = superuser_logged_in_client.delete( 

516 url, 

517 query_string={"uuid": user["_id"]}, 

518 ) 

519 

520 assert response.status_code == 200 

521 assert database.get_by_email("users", "dummy@dummy.com") is None 

522 

523 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

524 

525 

526def test_change_password(superuser_logged_in_client, database): 

527 """Test change password.""" 

528 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

529 

530 user = { 

531 "_id": uuid.uuid4().hex, 

532 "name": "dummy", 

533 "email": "dummy@dummy.com", 

534 "password": pbkdf2_sha512.hash("dummy"), 

535 } 

536 

537 database.insert("users", user) 

538 

539 url = f"/user/change_password?uuid={user['_id']}" 

540 response = superuser_logged_in_client.post( 

541 url, 

542 data={ 

543 "new_password": "new_dummy_password", 

544 "confirm_password": "new_dummy_password", 

545 }, 

546 content_type="application/x-www-form-urlencoded", 

547 ) 

548 

549 assert response.status_code == 200 

550 updated_user = database.get_by_email("users", "dummy@dummy.com") 

551 assert updated_user is not None 

552 assert pbkdf2_sha512.verify("new_dummy_password", updated_user["password"]) 

553 

554 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

555 

556 

557def test_change_password_mismatch(superuser_logged_in_client, database): 

558 """Test change password with mismatch.""" 

559 url = "/user/change_password" 

560 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

561 

562 user = { 

563 "_id": uuid.uuid4().hex, 

564 "name": "dummy", 

565 "email": "dummy@dummy.com", 

566 "password": pbkdf2_sha512.hash("dummy"), 

567 } 

568 

569 database.insert("users", user) 

570 

571 response = superuser_logged_in_client.post( 

572 url, 

573 data={ 

574 "uuid": user["_id"], 

575 "new_password": "new_dummy_password", 

576 "confirm_password": "mismatch_password", 

577 }, 

578 content_type="application/x-www-form-urlencoded", 

579 ) 

580 

581 assert response.status_code == 400 

582 assert b"Passwords don't match" in response.data 

583 

584 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

585 

586 

587def test_get_change_password_page(superuser_logged_in_client, database): 

588 """Test get change password page.""" 

589 url = "/user/change_password" 

590 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

591 

592 user = { 

593 "_id": uuid.uuid4().hex, 

594 "name": "dummy", 

595 "email": "dummy@dummy.com", 

596 "password": pbkdf2_sha512.hash("dummy"), 

597 } 

598 

599 database.insert("users", user) 

600 

601 response = superuser_logged_in_client.get(url, query_string={"uuid": user["_id"]}) 

602 

603 assert response.status_code == 200 

604 assert b"Change Password" in response.data 

605 

606 database.delete_all_by_field("users", "email", "dummy@dummy.com") 

607 

608 

609def test_send_match_email(user_logged_in_client, database): 

610 """Test send match email.""" 

611 url = "/user/send_match_email" 

612 database.delete_all_by_field("students", "email", "dummy_student@dummy.com") 

613 database.delete_all_by_field("employers", "email", "dummy_employer@dummy.com") 

614 database.delete_all_by_field("opportunities", "title", "dummy_opportunity") 

615 

616 student = { 

617 "_id": uuid.uuid4().hex, 

618 "first_name": "dummy_student", 

619 "email": "dummy_student@dummy.com", 

620 } 

621 

622 employer = { 

623 "_id": uuid.uuid4().hex, 

624 "company_name": "dummy_employer", 

625 "email": "dummy_employer@dummy.com", 

626 "password": pbkdf2_sha512.hash("dummy"), 

627 } 

628 

629 opportunity = { 

630 "_id": uuid.uuid4().hex, 

631 "title": "dummy_opportunity", 

632 "employer_id": employer["_id"], 

633 } 

634 

635 database.insert("students", student) 

636 database.insert("opportunities", opportunity) 

637 database.insert("employers", employer) 

638 

639 deadlines = database.get_all("deadline") 

640 if deadlines: 

641 database.delete_all("deadline") 

642 database.insert("deadline", {"type": 0, "deadline": "2022-10-10"}) 

643 database.insert("deadline", {"type": 1, "deadline": "2022-10-12"}) 

644 database.insert("deadline", {"type": 2, "deadline": "2022-10-15"}) 

645 

646 response = user_logged_in_client.post( 

647 url, 

648 data={ 

649 "student": student["_id"], 

650 "opportunity": opportunity["_id"], 

651 }, 

652 content_type="application/x-www-form-urlencoded", 

653 ) 

654 

655 assert response.status_code == 200 

656 assert response.json["message"] == "Email Sent" 

657 

658 database.delete_all_by_field("students", "email", "dummy_student@dummy.com") 

659 database.delete_all_by_field("employers", "email", "dummy_employer@dummy.com") 

660 database.delete_all_by_field("opportunities", "title", "dummy_opportunity") 

661 database.delete_all("deadline") 

662 for deadline in deadlines: 

663 database.insert("deadline", deadline) 

664 

665 

666def test_user_home(user_logged_in_client): 

667 """Test user home page.""" 

668 url = "/user/home" 

669 

670 response = user_logged_in_client.get(url) 

671 assert response.status_code == 200 

672 

673 

674def test_search_users_page(superuser_logged_in_client): 

675 """Test search users page.""" 

676 url = "/user/search" 

677 

678 response = superuser_logged_in_client.get(url) 

679 assert response.status_code == 200 

680 

681 

682def test_delete_opportunity(user_logged_in_client, database): 

683 """Test the delete opportunity.""" 

684 url = "/opportunities/employer_delete_opportunity?opportunity_id=123" 

685 

686 database.delete_all_by_field("opportunities", "_id", "123") 

687 database.insert("opportunities", {"_id": "123"}) 

688 

689 response = user_logged_in_client.get(url) 

690 

691 assert response.status_code == 302 

692 

693 

694def test_add_employer_post(user_logged_in_client, database): 

695 """Test POST request to add employer route.""" 

696 url = "/employers/add_employer" 

697 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

698 

699 employer_data = { 

700 "_id": uuid.uuid1().hex, 

701 "company_name": "dummy", 

702 "email": "dummy@dummy.com", 

703 } 

704 

705 response = user_logged_in_client.post( 

706 url, 

707 data=employer_data, 

708 content_type="application/x-www-form-urlencoded", 

709 ) 

710 assert response.status_code == 200 

711 

712 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

713 

714 

715def test_update_employer_post(user_logged_in_client, database): 

716 """Test POST request to update employer route.""" 

717 

718 url = "/employers/update_employer" 

719 

720 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

721 

722 database.insert( 

723 "employers", {"_id": "123", "company_name": "dummy", "email": "dummy@dummy.com"} 

724 ) 

725 

726 updated_data = { 

727 "employer_id": "123", 

728 "company_name": "dummy1", 

729 "email": "dummy@dummy.com", 

730 } 

731 

732 response = user_logged_in_client.post( 

733 url, 

734 data=updated_data, 

735 content_type="application/x-www-form-urlencoded", 

736 ) 

737 

738 assert response.status_code == 200 

739 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

740 

741 

742def test_update_employer_post_wrong_id(user_logged_in_client, database): 

743 """Test POST request to update employer route.""" 

744 

745 url = "/employers/update_employer" 

746 

747 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

748 

749 database.insert( 

750 "employers", {"_id": "123", "company_name": "dummy", "email": "dummy@dummy.com"} 

751 ) 

752 

753 updated_data = { 

754 "employer_id": "1234", 

755 "company_name": "dummy1", 

756 "email": "dummy@dummy.com", 

757 } 

758 

759 response = user_logged_in_client.post( 

760 url, 

761 data=updated_data, 

762 content_type="application/x-www-form-urlencoded", 

763 ) 

764 

765 assert response.status_code == 404 

766 assert response.json == {"error": "Employer not found"} 

767 

768 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

769 

770 

771def test_update_employer_get_wrong_id(user_logged_in_client): 

772 """Test GET request to update employer with a non-existent employer ID.""" 

773 

774 url = "/employers/update_employer?employer_id=9999" # Non-existent employer_id 

775 

776 response = user_logged_in_client.get( 

777 url, follow_redirects=True 

778 ) # Follow the redirect 

779 

780 assert ( 

781 response.status_code == 200 

782 ) # Since it redirects, it should be 200 after landing 

783 

784 

785def test_update_employer_get_method(user_logged_in_client, database): 

786 """Test GET request to update employer route.""" 

787 url = "/employers/update_employer" 

788 

789 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

790 

791 database.insert( 

792 "employers", {"_id": "123", "company_name": "dummy", "email": "dummy@dummy.com"} 

793 ) 

794 

795 response = user_logged_in_client.get(url, query_string={"employer_id": "123"}) 

796 

797 assert response.status_code == 200 

798 

799 

800def test_delete_employer_no_id(user_logged_in_client): 

801 """Test POST request to delete employer route without providing an employer ID.""" 

802 url = "/employers/delete_employer" 

803 

804 response = user_logged_in_client.post(url, json={}, content_type="application/json") 

805 

806 assert response.status_code == 400 

807 assert response.json == {"error": "Employer ID is required"} 

808 

809 

810def test_delete_employer(user_logged_in_client, database): 

811 """Test POST request to delete employer route.""" 

812 url = "/employers/delete_employer" 

813 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

814 

815 employer = {"_id": "123", "company_name": "dummy", "email": "dummy@dummy.com"} 

816 database.insert("employers", employer) 

817 

818 response = user_logged_in_client.post( 

819 url, 

820 json={"employer_id": "123"}, 

821 content_type="application/json", 

822 ) 

823 

824 assert response.status_code == 200 

825 assert response.json == {"message": "Employer deleted"} 

826 

827 database.delete_all_by_field("employers", "email", "dummy@dummy.com") 

828 

829 

830def test_employer_add_opportunity_post(user_logged_in_client, database): 

831 """Test the employer_update_opportunity page.""" 

832 url = "/opportunities/employer_add_update_opportunity" 

833 

834 database.delete_all_by_field("opportunities", "_id", "123") 

835 database.delete_all_by_field("opportunities", "_id", "1234") 

836 opportunity = { 

837 "_id": "1234", 

838 "title": "Software Internship", 

839 "description": "A great opportunity to learn.", 

840 "url": "https://example.com", 

841 "location": "Remote", 

842 "modules_required": '["CS101", "CS102"]', # Matches how the request expects it 

843 "courses_required": '["Computer_Science"]', 

844 "spots_available": 3, 

845 "duration": "6_months", 

846 } 

847 

848 with patch("app.DEADLINE_MANAGER.is_past_details_deadline", return_value=False): 

849 response = user_logged_in_client.post( 

850 url, data=opportunity, content_type="application/x-www-form-urlencoded" 

851 ) 

852 

853 assert response.status_code == 200 

854 database.delete_by_id("opportunities", "1234") 

855 database.delete_all_by_field("employers", "email", "dummy@dummy,com") 

856 

857 

858def test_delete_student(user_logged_in_client, database): 

859 """Test the delete student route.""" 

860 

861 student_id = 123 

862 

863 url = f"/students/delete_student/{student_id}" # Format the URL correctly 

864 

865 # Ensure no existing student with this ID 

866 database.delete_all_by_field("students", "_id", str(student_id)) 

867 

868 # Insert a test student with an integer ID 

869 student = { 

870 "student_id": str(student_id), 

871 "first_name": "dummy", 

872 "email": "dummy@dummy.com", 

873 } 

874 database.insert("students", student) 

875 

876 # Send DELETE request 

877 response = user_logged_in_client.delete(url) 

878 

879 # Check response 

880 assert response.status_code == 200 

881 assert response.json == {"message": "Student deleted"} 

882 

883 

884def test_register_student(user_logged_in_client, database): 

885 """Test the register student route.""" 

886 url = "/students/add_student" 

887 

888 database.delete_all_by_field( 

889 "students", "student_id", "123" 

890 ) # Ensure no existing student with this ID 

891 

892 student = { 

893 "student_id": "123", 

894 "first_name": "dummy", 

895 "last_name": "dummy", 

896 "email": "dummy@dummy.com", 

897 "course": "Computer Science", 

898 "modules": [], 

899 "comments": "", 

900 } 

901 

902 response = user_logged_in_client.post( 

903 url, json=student, content_type="application/json" 

904 )