Coverage for tests/model_tests/test_student.py: 99%

1"""Tests for the student model.""" 

2 

3import os 

4import sys 

5 

6from dotenv import load_dotenv 

7import pytest 

8 

9 

10# flake8: noqa: F811 

11 

12# Add the root directory to the Python path 

13sys.path.append( 

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

15) 

16from core import shared 

17from core.database_mongo_manager import DatabaseMongoManager 

18 

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

20 

21load_dotenv() 

22 

23 

24@pytest.fixture() 

25def app(): 

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

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

28 

29 return app 

30 

31 

32@pytest.fixture() 

33def client(): 

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

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

36 

37 return app.test_client() 

38 

39 

40@pytest.fixture() 

41def database(): 

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

43 

44 database = DatabaseMongoManager( 

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

46 ) 

47 current_students = database.get_all("students") 

48 database.delete_all("students") 

49 opportunities = database.get_all("opportunities") 

50 database.delete_all("opportunities") 

51 yield database 

52 database.delete_all("students") 

53 for student in current_students: 

54 database.insert("students", student) 

55 database.delete_all("opportunities") 

56 for opportunity in opportunities: 

57 database.insert("opportunities", opportunity) 

58 

59 # Cleanup code 

60 database.connection.close() 

61 

62 

63def test_add_student_success(app, database): 

64 """Test adding a student successfully.""" 

65 from students.models import Student 

66 

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

68 

69 student = { 

70 "_id": "123", 

71 "first_name": "dummy", 

72 "last_name": "dummy", 

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

74 "student_id": "123", 

75 } 

76 

77 with app.app_context(): 

78 with app.test_request_context(): 

79 response = Student().add_student(student) 

80 json_response = response[0].get_json() 

81 assert response[1] == 200 

82 assert json_response["message"] == "Student added" 

83 

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

85 database.delete_all_by_field("students", "_id", "123") 

86 

87 

88def test_add_student_no_id(app, database): 

89 """Test adding a student with no id.""" 

90 from students.models import Student 

91 

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

93 

94 student = { 

95 "_id": "123", 

96 "first_name": "dummy", 

97 "last_name": "dummy", 

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

99 "student_id": "123", 

100 } 

101 

102 database.insert("students", student) 

103 

104 with app.app_context(): 

105 with app.test_request_context(): 

106 response = Student().add_student(student) 

107 json_response = response[0].get_json() 

108 assert response[1] == 400 

109 assert json_response["error"] == "Student already in database" 

110 

111 

112def test_add_student_duplicate(app, database): 

113 """Test adding a student with a id.""" 

114 from students.models import Student 

115 

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

117 student1 = { 

118 "_id": "123", 

119 "first_name": "dummy1", 

120 "last_name": "dummy1", 

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

122 "student_id": "123", 

123 } 

124 

125 database.insert("students", student1) 

126 

127 student1 = { 

128 "_id": "124", 

129 "first_name": "dummy2", 

130 "last_name": "dummy2", 

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

132 "student_id": "123", 

133 } 

134 

135 with app.app_context(): 

136 with app.test_request_context(): 

137 response = Student().add_student(student1) 

138 json_response = response[0].get_json() 

139 assert response[1] == 400 

140 assert json_response["error"] == "Student already in database" 

141 assert database.get_one_by_id("students", "123")["first_name"] == "dummy1" 

142 assert ( 

143 len(database.get_all_by_field("students", "email", "dummy@dummy.com")) 

144 == 1 

145 ) 

146 

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

148 database.delete_all_by_field("students", "_id", "123") 

149 database.delete_all_by_field("students", "_id", "124") 

150 

151 

152def test_add_student_duplicate_override(app, database): 

153 """Test adding a student with a id.""" 

154 from students.models import Student 

155 

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

157 

158 student1 = { 

159 "_id": "123", 

160 "first_name": "dummy1", 

161 "last_name": "dummy1", 

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

163 "student_id": "123", 

164 } 

165 

166 database.insert("students", student1) 

167 

168 student1 = { 

169 "_id": "124", 

170 "first_name": "dummy2", 

171 "last_name": "dummy2", 

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

173 "student_id": "123", 

174 } 

175 

176 with app.app_context(): 

177 with app.test_request_context(): 

178 response = Student().add_student(student1, overwrite=True) 

179 assert response[1] == 200 

180 assert database.get_one_by_id("students", "124")["first_name"] == "dummy2" 

181 assert ( 

182 len(database.get_all_by_field("students", "email", "dummy@dummy.com")) 

183 == 1 

184 ) 

185 

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

187 database.delete_all_by_field("students", "_id", "123") 

188 

189 

190def test_get_student_by_id(database): 

191 """Test getting a student by id.""" 

192 from students.models import Student 

193 

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

195 

196 student1 = { 

197 "_id": "123", 

198 "first_name": "dummy1", 

199 "last_name": "dummy1", 

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

201 "student_id": "123", 

202 } 

203 

204 database.insert("students", student1) 

205 

206 assert Student().get_student_by_id("123") == student1 

207 

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

209 database.delete_all_by_field("students", "_id", "123") 

210 

211 

212def test_get_student_by_id_not_found(database): 

213 """Test getting a student by id that does not exist.""" 

214 

215 from students.models import Student 

216 

217 assert Student().get_student_by_id("999") is None 

218 

219 database.delete_all_by_field("students", "_id", "999") 

220 

221 

222def test_get_all_students(database): 

223 """Test getting all students from the database.""" 

224 from students.models import Student 

225 

226 count = len(database.get_all("students")) 

227 

228 actual = len(Student().get_students()) 

229 

230 assert count == actual 

231 

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

233 database.delete_all_by_field("students", "_id", "123") 

234 

235 

236def test_get_all_students_empty(database): 

237 """Test getting all students from the database when it is empty.""" 

238 from students.models import Student 

239 

240 current_students = database.get_all("students") 

241 database.delete_all("students") 

242 

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

244 

245 result = Student().get_students() 

246 

247 assert result == [] 

248 

249 for student in current_students: 

250 database.insert("students", student) 

251 

252 

253def test_get_student_map(database): 

254 """Test getting a student map.""" 

255 from students.models import Student 

256 

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

258 

259 student1 = { 

260 "_id": "123", 

261 "first_name": "dummy1", 

262 "last_name": "dummy1", 

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

264 "student_id": "123", 

265 } 

266 

267 database.insert("students", student1) 

268 

269 student2 = { 

270 "_id": "124", 

271 "first_name": "dummy2", 

272 "last_name": "dummy2", 

273 "email": "dummy2@dummy.com", 

274 "student_id": "123", 

275 } 

276 

277 database.insert("students", student2) 

278 

279 student_map = Student().get_students_map() 

280 assert student_map["123"] == student1 

281 assert student_map["124"] == student2 

282 

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

284 database.delete_all_by_field("students", "_id", "123") 

285 database.delete_all_by_field("students", "_id", "124") 

286 

287 

288def test_get_student_map_empty(database): 

289 """Test getting a student map when the database is empty.""" 

290 from students.models import Student 

291 

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

293 

294 student_map = Student().get_students_map() 

295 assert student_map == {} 

296 

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

298 

299 

300def test_get_student_by_uuid(database): 

301 """Test getting a student by uuid.""" 

302 from students.models import Student 

303 

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

305 

306 student1 = { 

307 "_id": "123", 

308 "first_name": "dummy1", 

309 "last_name": "dummy1", 

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

311 "student_id": "123", 

312 } 

313 

314 database.insert("students", student1) 

315 

316 assert Student().get_student_by_uuid("123") == student1 

317 

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

319 database.delete_all_by_field("students", "_id", "123") 

320 

321 

322def test_get_student_by_uuid_not_found(database): 

323 """Test getting a student by uuid that does not exist.""" 

324 from students.models import Student 

325 

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

327 

328 assert Student().get_student_by_uuid("999") is None 

329 

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

331 database.delete_all_by_field("students", "_id", "999") 

332 

333 

334def test_update_student_by_id_success(app, database): 

335 """Test updating a student by id successfully.""" 

336 from students.models import Student 

337 

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

339 

340 student1 = { 

341 "_id": "123", 

342 "first_name": "dummy1", 

343 "last_name": "dummy1", 

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

345 "student_id": "123", 

346 } 

347 

348 database.insert("students", student1) 

349 

350 updated_student = { 

351 "first_name": "updated_dummy", 

352 "last_name": "updated_dummy", 

353 "email": "updated_dummy@dummy.com", 

354 "student_id": "124", 

355 } 

356 

357 with app.app_context(): 

358 response = Student().update_student_by_id("123", updated_student) 

359 json_response = response[0].get_json() 

360 assert response[1] == 200 

361 assert json_response["message"] == "Student updated" 

362 

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

364 database.delete_all_by_field("students", "email", "updated_dummy@dummy.com") 

365 database.delete_all_by_field("students", "_id", "123") 

366 

367 

368def test_update_student_by_id_not_found(app, database): 

369 """Test updating a student by id that does not exist.""" 

370 

371 from students.models import Student 

372 

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

374 

375 updated_student = { 

376 "first_name": "updated_dummy", 

377 "last_name": "updated_dummy", 

378 "email": "updated_dummy@dummy.com", 

379 "student_id": "124", 

380 } 

381 

382 with app.app_context(): 

383 response = Student().update_student_by_id("999", updated_student) 

384 json_response = response[0].get_json() 

385 assert response[1] == 404 

386 assert json_response["error"] == "Student not found" 

387 

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

389 database.delete_all_by_field("students", "_id", "123") 

390 database.delete_all_by_field("students", "_id", "999") 

391 database.delete_all_by_field("students", "email", "updated_dummy@dummy.com") 

392 

393 

394def test_update_student_by_uuid_success(app, database): 

395 """Test updating a student by uuid successfully.""" 

396 

397 from students.models import Student 

398 

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

400 

401 student1 = { 

402 "_id": "123", 

403 "first_name": "dummy1", 

404 "last_name": "dummy1", 

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

406 "student_id": "123", 

407 } 

408 

409 database.insert("students", student1) 

410 

411 updated_student = { 

412 "first_name": "updated_dummy", 

413 "last_name": "updated_dummy", 

414 "email": "updated_dummy@dummy.com", 

415 "student_id": "124", 

416 } 

417 

418 with app.app_context(): 

419 response = Student().update_student_by_uuid("123", updated_student) 

420 json_response = response[0].get_json() 

421 assert response[1] == 200 

422 assert json_response["message"] == "Student updated" 

423 

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

425 database.delete_all_by_field("students", "_id", "123") 

426 database.delete_all_by_field("students", "_id", "124") 

427 database.delete_all_by_field("students", "email", "updated_dummy@dummy.com") 

428 

429 

430def test_update_student_by_uuid_not_found(app, database): 

431 """Test updating a student by uuid that does not exist.""" 

432 

433 from students.models import Student 

434 

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

436 

437 updated_student = { 

438 "first_name": "updated_dummy", 

439 "last_name": "updated_dummy", 

440 "email": "updated_dummy@dummy.com", 

441 "student_id": "124", 

442 } 

443 

444 with app.app_context(): 

445 response = Student().update_student_by_uuid("123", updated_student) 

446 json_response = response[0].get_json() 

447 assert response[1] == 404 

448 assert json_response["error"] == "Student not found" 

449 

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

451 database.delete_all_by_field("students", "_id", "123") 

452 database.delete_all_by_field("students", "_id", "124") 

453 database.delete_all_by_field("students", "email", "updated_dummy@dummy.com") 

454 

455 

456def test_delete_student_by_id(app, database): 

457 """Test deleting a student by id.""" 

458 

459 from students.models import Student 

460 

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

462 

463 student1 = { 

464 "_id": "123", 

465 "first_name": "dummy1", 

466 "last_name": "dummy1", 

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

468 "student_id": "123", 

469 } 

470 

471 database.insert("students", student1) 

472 

473 with app.app_context(): 

474 response = Student().delete_student_by_id("123") 

475 json_response = response[0].get_json() 

476 assert response[1] == 200 

477 assert json_response["message"] == "Student deleted" 

478 

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

480 database.delete_all_by_field("students", "_id", "123") 

481 

482 

483def test_delete_student_by_id_opportunities(app, database): 

484 """Test deleting a student by id with opportunities.""" 

485 

486 from students.models import Student 

487 from unittest.mock import patch 

488 

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

490 database.delete_all_by_field("modules", "module_id", "123") 

491 database.delete_all_by_field("modules", "module_id", "124") 

492 database.delete_all_by_field("opportunities", "title", "dummy1") 

493 database.delete_all_by_field("opportunities", "title", "dummy2") 

494 

495 student1 = { 

496 "_id": "123", 

497 "first_name": "dummy1", 

498 "last_name": "dummy1", 

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

500 "student_id": "123", 

501 } 

502 

503 database.insert("students", student1) 

504 

505 opportunity1 = { 

506 "_id": "123", 

507 "title": "dummy1", 

508 "description": "dummy1", 

509 "modules_required": ["123"], 

510 "courses_required": ["123"], 

511 "duration": "1_day", 

512 "preferences": ["123"], 

513 } 

514 database.insert("opportunities", opportunity1) 

515 

516 opportunity2 = { 

517 "_id": "124", 

518 "title": "dummy2", 

519 "description": "dummy2", 

520 "modules_required": ["123", "124"], 

521 "courses_required": ["123"], 

522 "duration": "1_week", 

523 } 

524 database.insert("opportunities", opportunity2) 

525 

526 with patch("app.DATABASE_MANAGER.update_one_by_id"): 

527 with app.app_context(): 

528 response = Student().delete_student_by_id("123") 

529 json_response = response[0].get_json() 

530 assert response[1] == 200 

531 assert json_response["message"] == "Student deleted" 

532 

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

534 database.delete_all_by_field("students", "_id", "123") 

535 database.delete_all_by_field("opportunities", "title", "dummy1") 

536 database.delete_all_by_field("opportunities", "title", "dummy1") 

537 

538 

539def test_delete_student_by_id_not_found(app, database): 

540 """Test deleting a student by id that does not exist.""" 

541 

542 from students.models import Student 

543 

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

545 

546 with app.app_context(): 

547 response = Student().delete_student_by_id("123") 

548 json_response = response[0].get_json() 

549 assert response[1] == 404 

550 assert json_response["error"] == "Student not found" 

551 

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

553 database.delete_all_by_field("students", "_id", "123") 

554 

555 

556def test_delete_students(app, database): 

557 """Test deleting all students.""" 

558 

559 from students.models import Student 

560 

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

562 current_students = database.get_all("students") 

563 

564 student1 = { 

565 "_id": "123", 

566 "first_name": "dummy1", 

567 "last_name": "dummy1", 

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

569 "student_id": "123", 

570 } 

571 

572 database.insert("students", student1) 

573 

574 student2 = { 

575 "_id": "124", 

576 "first_name": "dummy2", 

577 "last_name": "dummy2", 

578 "email": "dummy2@dummy.com", 

579 "student_id": "124", 

580 } 

581 

582 database.insert("students", student2) 

583 

584 with app.app_context(): 

585 response = Student().delete_students() 

586 json_response = response[0].get_json() 

587 assert response[1] == 200 

588 assert json_response["message"] == "All students deleted" 

589 assert len(database.get_all("students")) == 0 

590 

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

592 database.delete_all_by_field("students", "_id", "123") 

593 database.delete_all_by_field("students", "_id", "124") 

594 

595 for student in current_students: 

596 database.insert("students", student) 

597 

598 

599def test_get_student_by_email(app, database): 

600 """Test getting a student by email.""" 

601 from students.models import Student 

602 

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

604 

605 student1 = { 

606 "_id": "123", 

607 "first_name": "dummy1", 

608 "last_name": "dummy1", 

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

610 "student_id": "123", 

611 } 

612 

613 database.insert("students", student1) 

614 

615 with app.app_context(): 

616 response = Student().get_student_by_email("dummy@dummy.com") 

617 assert response[1] == 200 

618 

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

620 database.delete_all_by_field("students", "_id", "123") 

621 

622 

623def test_get_student_by_email_not_found(app): 

624 """Test getting a student by email that does not exist.""" 

625 from students.models import Student 

626 

627 with app.app_context(): 

628 response = Student().get_student_by_email("dummy@dummy.com") 

629 json_response = response[0].get_json() 

630 assert response[1] == 404 

631 assert json_response["error"] == "Student not found" 

632 

633 

634def test_import_from_xlsx_valid(app, database): 

635 """Test importing students from a valid xlsx file.""" 

636 from students.models import Student 

637 

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

639 

640 with app.app_context(): 

641 with app.test_request_context(): 

642 with open("tests/data/valid_students.xlsx", "rb") as f: 

643 response = Student().import_from_xlsx("dummy.com", f) 

644 json_response = response[0].get_json() 

645 assert response[1] == 200 

646 assert json_response["message"] == "27 students imported" 

647 

648 students = database.get_all("students") 

649 assert len(students) == 27 

650 

651 database.delete_all("students") 

652 

653 

654def test_import_from_xlsx_invalid_email(app, database): 

655 """Test importing students from a xlsx file with invalid email.""" 

656 

657 from students.models import Student 

658 

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

660 

661 with app.app_context(): 

662 with open("tests/data/Invalid_students_email.xlsx", "rb") as f: 

663 response = Student().import_from_xlsx("dummy.com", f) 

664 json_response = response[0].get_json() 

665 assert json_response["error"] == "Invalid student dummy1, dummy1" 

666 assert response[1] == 400 

667 

668 students = database.get_all_by_field("students", "email", "dummy@dummy.com") 

669 assert len(students) == 0 

670 

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

672 

673 

674def test_import_from_xlsx_invalid_student_id(app, database): 

675 """Test importing students from a xlsx file with invalid student id.""" 

676 from students.models import Student 

677 

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

679 

680 with app.app_context(): 

681 with open("tests/data/Invalid_students_Id.xlsx", "rb") as f: 

682 response = Student().import_from_xlsx("dummy.com", f) 

683 json_response = response[0].get_json() 

684 assert json_response["error"] == "Invalid student dummy1, dummy1" 

685 assert response[1] == 400 

686 

687 students = database.get_all_by_field("students", "email", "dummy@dummy.com") 

688 assert len(students) == 0 

689 

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

691 

692 

693def test_import_from_wrong_format(app, database): 

694 """Test importing students from a xlsx file with wrong format.""" 

695 from students.models import Student 

696 

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

698 

699 with app.app_context(): 

700 with open("tests/data/Invalid_doc_type.docx", "rb") as f: 

701 

702 response = Student().import_from_xlsx("dummy.com", f) 

703 

704 assert response[1] == 400 

705 assert ( 

706 response[0].get_json()["error"] 

707 == "Failed to read file: Invalid file type. Please upload a .xlsx file." 

708 ) 

709 

710 students = database.get_all_by_field("students", "email", "dummy@dummy.com") 

711 assert len(students) == 0 

712 

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

714 

715 

716def test_student_login(app, database): 

717 """Test student login""" 

718 from students.models import Student 

719 

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

721 

722 student1 = { 

723 "_id": "123", 

724 "first_name": "dummy1", 

725 "last_name": "dummy1", 

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

727 "student_id": "123", 

728 } 

729 

730 database.insert("students", student1) 

731 

732 with app.app_context(): 

733 with app.test_request_context(): 

734 response = Student().student_login(student1["student_id"]) 

735 json_response = response[0].get_json() 

736 assert response[1] == 200 

737 assert json_response["message"] == "OTP sent" 

738 

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

740 database.delete_all_by_field("students", "_id", "123") 

741 

742 

743def test_student_login_non_existant(app, database): 

744 """Test student login with a non-existant student""" 

745 from students.models import Student 

746 

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

748 

749 student1 = { 

750 "_id": "123", 

751 "first_name": "dummy1", 

752 "last_name": "dummy1", 

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

754 "student_id": "123", 

755 } 

756 with app.app_context(): 

757 with app.test_request_context(): 

758 response = Student().student_login(student1["student_id"]) 

759 json_response = response[0].get_json() 

760 assert response[1] == 404 

761 assert json_response["error"] == "Student not found" 

762 

763 

764def test_rank_preferences(app, database): 

765 """Test ranking preferences""" 

766 from students.models import Student 

767 

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

769 

770 student1 = { 

771 "_id": "123", 

772 "first_name": "dummy1", 

773 "last_name": "dummy1", 

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

775 "student_id": "123", 

776 } 

777 

778 database.insert("students", student1) 

779 

780 with app.app_context(): 

781 with app.test_request_context(): 

782 response = Student().rank_preferences( 

783 student1["student_id"], ["1", "2", "3"] 

784 ) 

785 json_response = response[0].get_json() 

786 assert response[1] == 200 

787 assert json_response["message"] == "Preferences updated" 

788 

789 

790def test_rank_preferences_invalid_student(app, database): 

791 """Test ranking preferences with an invalid student""" 

792 from students.models import Student 

793 

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

795 

796 with app.app_context(): 

797 with app.test_request_context(): 

798 response = Student().rank_preferences(["student_id"], ["1", "2", "3"]) 

799 json_response = response[0].get_json() 

800 assert json_response["error"] == "Student not found" 

801 assert response[1] == 404 

802 

803 

804def test_get_opportunities_by_student(app, database): 

805 """Test getting opportunities by student""" 

806 from students.models import Student 

807 

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

809 database.delete_all_by_field("modules", "module_id", "123") 

810 database.delete_all_by_field("modules", "module_id", "124") 

811 database.delete_all_by_field("courses", "course_id", "123") 

812 database.delete_all_by_field("opportunities", "title", "dummy1") 

813 database.delete_all_by_field("opportunities", "title", "dummy2") 

814 database.delete_all_by_field("opportunities", "title", "dummy3") 

815 

816 module1 = { 

817 "_id": "123", 

818 "module_id": "123", 

819 "module_name": "dummy1", 

820 "module_description": "dummy1", 

821 } 

822 database.insert("modules", module1) 

823 module2 = { 

824 "_id": "124", 

825 "module_id": "124", 

826 "module_name": "dummy2", 

827 "module_description": "dummy2", 

828 } 

829 database.insert("modules", module2) 

830 

831 course = { 

832 "_id": "123", 

833 "course_id": "123", 

834 "course_name": "dummy1", 

835 "course_description": "dummy1", 

836 } 

837 database.insert("courses", course) 

838 

839 opportunity1 = { 

840 "_id": "123", 

841 "title": "dummy1",