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

1"""Tests for the skills routes.""" 

2 

3# pylint: disable=redefined-outer-name 

4# flake8: noqa: F811 

5 

6import os 

7import sys 

8import uuid 

9import pytest 

10from dotenv import load_dotenv 

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) 

16 

17from core import shared 

18from core.database_mongo_manager import DatabaseMongoManager 

19 

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

21 

22load_dotenv() 

23 

24 

25@pytest.fixture() 

26def app(): 

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

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

29 

30 return app 

31 

32 

33@pytest.fixture() 

34def database(): 

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

36 

37 database = DatabaseMongoManager( 

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

39 ) 

40 skills = database.get_all("skills") 

41 attempted_skills = database.get_all("attempted_skills") 

42 database.delete_all("skills") 

43 database.delete_all("attempted_skills") 

44 yield database 

45 

46 for skill in skills: 

47 database.insert("skills", skill) 

48 for skill in attempted_skills: 

49 database.insert("attempted_skills", skill) 

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

51 database.delete_all_by_field("courses", "course_id", "CS101") 

52 # Cleanup code 

53 database.connection.close() 

54 

55 

56@pytest.fixture() 

57def skill_model(): 

58 """Fixture to create a Course model instance.""" 

59 from skills.models import Skill 

60 

61 return Skill() 

62 

63 

64@pytest.fixture() 

65def sample_skill(database): 

66 """Fixture to create a sample course.""" 

67 yield { 

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

69 "skill_name": "Test Skill", 

70 "skill_description": "Test Skill Description", 

71 } 

72 database.delete_all_by_field("skills", "skill_name", "Test Skill") 

73 

74 

75def test_find_skill_by_id(database, sample_skill, app, skill_model): 

76 """Test find_skill method by ID.""" 

77 

78 database.insert("skills", sample_skill) 

79 

80 skill_id = sample_skill["_id"] 

81 

82 with app.app_context(): 

83 with app.test_request_context(): 

84 skill = skill_model.find_skill(None, skill_id) 

85 assert skill["_id"] == sample_skill["_id"] 

86 assert skill["skill_name"] == sample_skill["skill_name"] 

87 assert skill["skill_description"] == sample_skill["skill_description"] 

88 

89 database.delete_all_by_field("skills", "skill_name", "Test Skill") 

90 

91 

92def test_add_skill(database, skill_model, app): 

93 """Test add_skill method.""" 

94 database.delete_all_by_field("skills", "skill_name", "New Skill") 

95 

96 sample_skill = { 

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

98 "skill_name": "New Skill", 

99 "skill_description": "New Skill Description", 

100 } 

101 

102 with app.app_context(): 

103 with app.test_request_context(): 

104 response = skill_model.add_skill(sample_skill)[0] 

105 assert response.status_code == 200 

106 assert database.get_one_by_id("skills", sample_skill["_id"]) is not None 

107 

108 database.delete_all_by_field("skills", "skill_name", "New Skill") 

109 

110 

111def test_delete_skill(database, skill_model, app): 

112 """Test delete_skill method.""" 

113 database.delete_all_by_field("skills", "skill_name", "Delete Skill") 

114 sample_skill = { 

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

116 "skill_name": "Delete Skill", 

117 "skill_description": "Skill to delete", 

118 } 

119 database.insert("skills", sample_skill) 

120 

121 with app.app_context(): 

122 with app.test_request_context(): 

123 response = skill_model.delete_skill(sample_skill["_id"])[0] 

124 assert response.status_code == 200 

125 assert database.get_one_by_id("skills", sample_skill["_id"]) is None 

126 

127 database.delete_all_by_field("skills", "skill_name", "Delete Skill") 

128 

129 

130def test_get_skill_by_id(database, skill_model, app): 

131 """Test get_skill_by_id method.""" 

132 database.delete_all_by_field("skills", "skill_name", "Find Skill") 

133 sample_skill = { 

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

135 "skill_name": "Find Skill", 

136 "skill_description": "Skill to find", 

137 } 

138 database.insert("skills", sample_skill) 

139 

140 with app.app_context(): 

141 with app.test_request_context(): 

142 skill = skill_model.get_skill_by_id(sample_skill["_id"]) 

143 assert skill is not None 

144 assert skill["skill_name"] == "Find Skill" 

145 

146 database.delete_all_by_field("skills", "skill_name", "Find Skill") 

147 

148 

149def test_get_skills(database, skill_model, app): 

150 """Test get_skills method.""" 

151 sample_skill = { 

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

153 "skill_name": "List Skill", 

154 "skill_description": "Skill in list", 

155 } 

156 database.insert("skills", sample_skill) 

157 

158 with app.app_context(): 

159 with app.test_request_context(): 

160 skills = skill_model.get_skills() 

161 assert any(skill["skill_name"] == "List Skill" for skill in skills) 

162 

163 database.delete_all_by_field("skills", "skill_name", "List Skill") 

164 

165 

166def test_update_skill(database, skill_model, app): 

167 """Test update_skill method.""" 

168 database.delete_all_by_field("skills", "skill_name", "Updated Skill") 

169 database.delete_all_by_field("skills", "skill_name", "Old Skill") 

170 database.delete_all_by_field("skills", "skill_name", "Updated skill") 

171 database.delete_all_by_field("skills", "skill_name", "Old skill") 

172 sample_skill = { 

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

174 "skill_name": "Old Skill", 

175 "skill_description": "Old description", 

176 } 

177 database.insert("skills", sample_skill) 

178 

179 with app.app_context(): 

180 with app.test_request_context(): 

181 response = skill_model.update_skill( 

182 sample_skill["_id"], "Updated Skill", "Updated description" 

183 )[0] 

184 assert response.status_code == 200 

185 updated_skill = database.get_one_by_id("skills", sample_skill["_id"]) 

186 assert updated_skill["skill_name"] == "Updated skill" 

187 

188 database.delete_all_by_field("skills", "skill_name", "Updated Skill") 

189 

190 

191def test_attempt_add_skill(database, skill_model, app): 

192 """Test attempt_add_skill method.""" 

193 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill") 

194 with app.app_context(): 

195 with app.test_request_context(): 

196 response = skill_model.attempt_add_skill("Attempted Skill")[0] 

197 assert response.status_code == 200 

198 assert ( 

199 database.get_one_by_field( 

200 "attempted_skills", "skill_name", "Attempted Skill" 

201 ) 

202 is not None 

203 ) 

204 

205 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill") 

206 

207 

208def test_approve_skill(database, skill_model, app): 

209 """Test approve_skill method.""" 

210 database.delete_all_by_field("skills", "skill_name", "Approve Skill") 

211 database.delete_all_by_field("attempted_skills", "skill_name", "Approve Skill") 

212 database.delete_all_by_field("skills", "skill_name", "Approve skill") 

213 attempted_skill = { 

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

215 "skill_name": "Approve Skill", 

216 "used": 1, 

217 } 

218 database.insert("attempted_skills", attempted_skill) 

219 

220 with app.app_context(): 

221 with app.test_request_context(): 

222 response = skill_model.approve_skill( 

223 attempted_skill["_id"], "Approved Description" 

224 )[0] 

225 assert response.status_code == 200 

226 assert database.get_one_by_id("skills", attempted_skill["_id"]) is not None 

227 

228 database.delete_all_by_field("skills", "skill_name", "Approve Skill") 

229 database.delete_all_by_field("attempted_skills", "skill_name", "Approve Skill") 

230 database.delete_all_by_field("skills", "skill_name", "Approve skill") 

231 

232 

233def test_reject_skill(database, skill_model, app): 

234 """Test reject_skill method.""" 

235 database.delete_all_by_field("skills", "skill_name", "Reject Skill") 

236 database.delete_all_by_field("attempted_skills", "skill_name", "Reject Skill") 

237 attempted_skill = { 

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

239 "skill_name": "Reject Skill", 

240 "used": 1, 

241 } 

242 database.insert("attempted_skills", attempted_skill) 

243 

244 with app.app_context(): 

245 with app.test_request_context(): 

246 response = skill_model.reject_skill(attempted_skill["_id"])[0] 

247 assert response.status_code == 200 

248 assert ( 

249 database.get_one_by_id("attempted_skills", attempted_skill["_id"]) 

250 is None 

251 ) 

252 

253 database.delete_all_by_field("attempted_skills", "skill_name", "Reject Skill") 

254 

255 

256def test_update_skill_name_conflict(database, skill_model, app): 

257 """Test update_skill method with name conflict.""" 

258 database.delete_all_by_field("skills", "skill_name", "Conflict Skill") 

259 database.delete_all_by_field("skills", "skill_name", "Existing Skill") 

260 

261 existing_skill = { 

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

263 "skill_name": "Existing Skill", 

264 "skill_description": "Existing description", 

265 } 

266 database.insert("skills", existing_skill) 

267 

268 sample_skill = { 

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

270 "skill_name": "Conflict Skill", 

271 "skill_description": "Conflict description", 

272 } 

273 database.insert("skills", sample_skill) 

274 

275 with app.app_context(): 

276 with app.test_request_context(): 

277 response = skill_model.update_skill( 

278 sample_skill["_id"], "Existing Skill", "Updated description" 

279 ) 

280 assert response[1] == 400 

281 assert response[0].json["error"] == "Skill name already in use" 

282 

283 database.delete_all_by_field("skills", "skill_name", "Conflict Skill") 

284 database.delete_all_by_field("skills", "skill_name", "Existing Skill") 

285 

286 

287def test_update_invalid_skill(database, skill_model, app, sample_skill): 

288 """Test update_skill method with invalid skill.""" 

289 with app.app_context(): 

290 with app.test_request_context(): 

291 response = skill_model.update_skill( 

292 sample_skill["_id"], "Updated Skill", "Updated description" 

293 ) 

294 assert response[1] == 404 

295 assert response[0].json["error"] == "Skill not found" 

296 

297 database.delete_all_by_field("skills", "skill_name", "Invalid Skill") 

298 

299 

300def test_find_skill_return_none(skill_model, app): 

301 """Test find_skill method returns None for non-existent skill.""" 

302 with app.app_context(): 

303 with app.test_request_context(): 

304 skill = skill_model.find_skill(skill_name="NonExistentSkill") 

305 assert skill is None 

306 

307 skill = skill_model.find_skill(skill_id="nonexistentid") 

308 assert skill is None 

309 

310 

311def test_add_existing_skill(database, skill_model, app): 

312 """Test add_skill method with existing skill.""" 

313 database.delete_all_by_field("skills", "skill_name", "Existing Skill") 

314 

315 existing_skill = { 

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

317 "skill_name": "Existing Skill", 

318 "skill_description": "Existing description", 

319 } 

320 database.insert("skills", existing_skill) 

321 

322 with app.app_context(): 

323 with app.test_request_context(): 

324 response = skill_model.add_skill(existing_skill) 

325 assert response[1] == 400 

326 assert response[0].json["error"] == "Skill already in database" 

327 

328 database.delete_all_by_field("skills", "skill_name", "Existing Skill") 

329 

330 

331def test_delete_skill_with_students(database, skill_model, app): 

332 """Test delete_skill method with students having the skill.""" 

333 database.delete_all_by_field("skills", "skill_name", "Skill to Delete") 

334 database.delete_all_by_field("students", "email", "student@example.com") 

335 

336 sample_skill = { 

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

338 "skill_name": "Skill to Delete", 

339 "skill_description": "Skill to be deleted", 

340 } 

341 database.insert("skills", sample_skill) 

342 

343 sample_student = { 

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

345 "email": "student@example.com", 

346 "skills": [sample_skill["_id"]], 

347 } 

348 database.insert("students", sample_student) 

349 

350 with app.app_context(): 

351 with app.test_request_context(): 

352 response = skill_model.delete_skill(sample_skill["_id"])[0] 

353 assert response.status_code == 200 

354 assert database.get_one_by_id("skills", sample_skill["_id"]) is None 

355 updated_student = database.get_one_by_id("students", sample_student["_id"]) 

356 assert sample_skill["_id"] not in updated_student["skills"] 

357 

358 database.delete_all_by_field("skills", "skill_name", "Skill to Delete") 

359 database.delete_all_by_field("students", "email", "student@example.com") 

360 

361 

362def test_delete_nonexistent_skill(skill_model, app): 

363 """Test delete_skill method with non-existent skill.""" 

364 with app.app_context(): 

365 with app.test_request_context(): 

366 response = skill_model.delete_skill("nonexistentid") 

367 assert response[1] == 404 

368 assert response[0].json["error"] == "Skill not found" 

369 

370 

371def test_get_skill_by_id_returns_none(skill_model, app): 

372 """Test get_skill_by_id method returns None for non-existent skill.""" 

373 with app.app_context(): 

374 with app.test_request_context(): 

375 skill = skill_model.get_skill_by_id("nonexistentid") 

376 assert skill is None 

377 

378 

379def test_get_skill_name_by_id(database, skill_model, app): 

380 """Test get_skill_name_by_id method.""" 

381 database.delete_all_by_field("skills", "skill_name", "Skill Name") 

382 sample_skill = { 

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

384 "skill_name": "Skill Name", 

385 "skill_description": "Skill Description", 

386 } 

387 database.insert("skills", sample_skill) 

388 

389 with app.app_context(): 

390 with app.test_request_context(): 

391 skill_name = skill_model.get_skill_name_by_id(sample_skill["_id"]) 

392 assert skill_name == "Skill Name" 

393 

394 skill_name = skill_model.get_skill_name_by_id("nonexistentid") 

395 assert skill_name is None 

396 

397 database.delete_all_by_field("skills", "skill_name", "Skill Name") 

398 

399 

400def test_get_skills_map(database, skill_model, app): 

401 """Test get_skills_map method.""" 

402 database.delete_all_by_field("skills", "skill_name", "Skill 1") 

403 database.delete_all_by_field("skills", "skill_name", "Skill 2") 

404 sample_skill_1 = { 

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

406 "skill_name": "Skill 1", 

407 "skill_description": "Description 1", 

408 } 

409 sample_skill_2 = { 

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

411 "skill_name": "Skill 2", 

412 "skill_description": "Description 2", 

413 } 

414 database.insert("skills", sample_skill_1) 

415 database.insert("skills", sample_skill_2) 

416 

417 with app.app_context(): 

418 with app.test_request_context(): 

419 skills_map = skill_model.get_skills_map() 

420 assert sample_skill_1["_id"] in skills_map 

421 assert sample_skill_2["_id"] in skills_map 

422 assert skills_map[sample_skill_1["_id"]]["skill_name"] == "Skill 1" 

423 assert skills_map[sample_skill_2["_id"]]["skill_name"] == "Skill 2" 

424 

425 database.delete_all_by_field("skills", "skill_name", "Skill 1") 

426 database.delete_all_by_field("skills", "skill_name", "Skill 2") 

427 

428 

429def test_attempt_add_existing_skill(database, skill_model, app): 

430 """Test attempt_add_skill method with existing skill.""" 

431 database.delete_all_by_field( 

432 "attempted_skills", "skill_name", "Existing Attempted Skill" 

433 ) 

434 existing_skill = { 

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

436 "skill_name": "Existing Attempted Skill", 

437 "used": 1, 

438 } 

439 database.insert("attempted_skills", existing_skill) 

440 

441 with app.app_context(): 

442 with app.test_request_context(): 

443 response = skill_model.attempt_add_skill("Existing Attempted Skill")[0] 

444 assert response.status_code == 200 

445 updated_skill = database.get_one_by_field( 

446 "attempted_skills", "skill_name", "Existing Attempted Skill" 

447 ) 

448 assert updated_skill["used"] == 2 

449 

450 database.delete_all_by_field( 

451 "attempted_skills", "skill_name", "Existing Attempted Skill" 

452 ) 

453 

454 

455def test_get_list_attempted_skills(database, skill_model, app): 

456 """Test get_list_attempted_skills method.""" 

457 current_attempted_skills = database.get_all("attempted_skills") 

458 database.delete_all("attempted_skills") 

459 

460 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill 1") 

461 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill 2") 

462 

463 sample_skill_1 = { 

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

465 "skill_name": "Attempted Skill 1", 

466 "used": 1, 

467 } 

468 sample_skill_2 = { 

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

470 "skill_name": "Attempted Skill 2", 

471 "used": 1, 

472 } 

473 database.insert("attempted_skills", sample_skill_1) 

474 database.insert("attempted_skills", sample_skill_2) 

475 

476 with app.app_context(): 

477 with app.test_request_context(): 

478 attempted_skills = skill_model.get_list_attempted_skills() 

479 assert len(attempted_skills) == 2 

480 assert any( 

481 skill["skill_name"] == "Attempted Skill 1" for skill in attempted_skills 

482 ) 

483 assert any( 

484 skill["skill_name"] == "Attempted Skill 2" for skill in attempted_skills 

485 ) 

486 

487 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill 1") 

488 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill 2") 

489 

490 for skill in current_attempted_skills: 

491 database.insert("attempted_skills", skill) 

492 

493 

494def test_get_attempted_skill_success(database, skill_model, app): 

495 """Test get_attempted_skill method success.""" 

496 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill") 

497 sample_skill = { 

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

499 "skill_name": "Attempted Skill", 

500 "used": 1, 

501 } 

502 database.insert("attempted_skills", sample_skill) 

503 

504 with app.app_context(): 

505 with app.test_request_context(): 

506 skill = skill_model.get_attempted_skill(sample_skill["_id"]) 

507 assert skill is not None 

508 assert skill["skill_name"] == "Attempted Skill" 

509 

510 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill") 

511 

512 

513def test_get_attempted_skill_failure(skill_model, app): 

514 """Test get_attempted_skill method failure.""" 

515 with app.app_context(): 

516 with app.test_request_context(): 

517 skill = skill_model.get_attempted_skill("nonexistentid") 

518 assert skill is None 

519 

520 

521def test_approve_skill_updates_students(database, skill_model, app): 

522 """Test approve_skill method updates students.""" 

523 database.delete_all_by_field("skills", "skill_name", "Approve Skill") 

524 database.delete_all_by_field("attempted_skills", "skill_name", "Approve Skill") 

525 database.delete_all_by_field("students", "email", "student@example.com") 

526 

527 attempted_skill = { 

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

529 "skill_name": "Approve Skill", 

530 "used": 1, 

531 } 

532 database.insert("attempted_skills", attempted_skill) 

533 

534 sample_student = { 

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

536 "email": "student@example.com", 

537 "skills": [], 

538 "attempted_skills": [attempted_skill["_id"]], 

539 } 

540 database.insert("students", sample_student) 

541 

542 with app.app_context(): 

543 with app.test_request_context(): 

544 response = skill_model.approve_skill( 

545 attempted_skill["_id"], "Approved Description" 

546 )[0] 

547 assert response.status_code == 200 

548 assert database.get_one_by_id("skills", attempted_skill["_id"]) is not None 

549 

550 updated_student = database.get_one_by_id("students", sample_student["_id"]) 

551 assert attempted_skill["_id"] in updated_student["skills"] 

552 assert attempted_skill["_id"] not in updated_student["attempted_skills"] 

553 

554 database.delete_all_by_field("skills", "skill_name", "Approve Skill") 

555 database.delete_all_by_field("attempted_skills", "skill_name", "Approve Skill") 

556 database.delete_all_by_field("students", "email", "student@example.com") 

557 

558 

559def test_approve_skill_empty_description(database, skill_model, app): 

560 """Test approve_skill method with empty description.""" 

561 database.delete_all_by_field("attempted_skills", "skill_name", "Approve Skill") 

562 attempted_skill = { 

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

564 "skill_name": "Approve Skill", 

565 "used": 1, 

566 } 

567 database.insert("attempted_skills", attempted_skill) 

568 

569 with app.app_context(): 

570 with app.test_request_context(): 

571 response = skill_model.approve_skill(attempted_skill["_id"], "") 

572 assert response[1] == 400 

573 assert response[0].json["error"] == "Description is empty" 

574 

575 database.delete_all_by_field("attempted_skills", "skill_name", "Approve Skill") 

576 

577 

578def test_approve_nonexistent_skill(skill_model, app): 

579 """Test approve_skill method with non-existent skill.""" 

580 with app.app_context(): 

581 with app.test_request_context(): 

582 response = skill_model.approve_skill("nonexistentid", "Description") 

583 assert response[1] == 404 

584 assert response[0].json["error"] == "Attempted skill not found" 

585 

586 

587def test_reject_skill_updates_students(database, skill_model, app): 

588 """Test reject_skill method updates students.""" 

589 database.delete_all_by_field("attempted_skills", "skill_name", "Reject Skill") 

590 database.delete_all_by_field("students", "email", "student@example.com") 

591 

592 attempted_skill = { 

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

594 "skill_name": "Reject Skill", 

595 "used": 1, 

596 } 

597 database.insert("attempted_skills", attempted_skill) 

598 

599 sample_student = { 

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

601 "email": "student@example.com", 

602 "skills": [], 

603 "attempted_skills": [attempted_skill["_id"]], 

604 } 

605 database.insert("students", sample_student) 

606 

607 with app.app_context(): 

608 with app.test_request_context(): 

609 response = skill_model.reject_skill(attempted_skill["_id"])[0] 

610 assert response.status_code == 200 

611 assert ( 

612 database.get_one_by_id("attempted_skills", attempted_skill["_id"]) 

613 is None 

614 ) 

615 

616 updated_student = database.get_one_by_id("students", sample_student["_id"]) 

617 assert attempted_skill["_id"] not in updated_student["attempted_skills"] 

618 

619 database.delete_all_by_field("attempted_skills", "skill_name", "Reject Skill") 

620 database.delete_all_by_field("students", "email", "student@example.com") 

621 

622 

623def test_reject_nonexistent_skill(skill_model, app): 

624 """Test reject_skill method with non-existent skill.""" 

625 with app.app_context(): 

626 with app.test_request_context(): 

627 response = skill_model.reject_skill("nonexistentid") 

628 assert response[1] == 404 

629 assert response[0].json["error"] == "Attempted skill not found" 

630 

631 

632def test_update_attempt_skill(database, skill_model, app): 

633 """Test update_attempt_skill method.""" 

634 database.delete_all_by_field("attempted_skills", "skill_name", "Attempted Skill") 

635 sample_skill = { 

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

637 "skill_name": "Attempted Skill", 

638 "skill_description": "Old Description", 

639 } 

640 database.insert("attempted_skills", sample_skill) 

641 

642 with app.app_context(): 

643 with app.test_request_context(): 

644 response = skill_model.update_attempt_skill( 

645 sample_skill["_id"], "Updated Skill", "Updated Description" 

646 )[0] 

647 assert response.status_code == 200 

648 updated_skill = database.get_one_by_id( 

649 "attempted_skills", sample_skill["_id"] 

650 ) 

651 assert updated_skill["skill_name"] == "Updated Skill" 

652 assert updated_skill["skill_description"] == "Updated Description" 

653 

654 database.delete_all_by_field("attempted_skills", "skill_name", "Updated Skill") 

655 

656 

657def test_update_attempt_skill_invalid_id(skill_model, app): 

658 """Test update_attempt_skill method with invalid skill ID.""" 

659 with app.app_context(): 

660 with app.test_request_context(): 

661 response = skill_model.update_attempt_skill( 

662 "nonexistentid", "Updated Skill", "Updated Description" 

663 ) 

664 assert response[1] == 404 

665 assert response[0].json["error"] == "Skill not found" 

666 

667 

668def test_delete_all_attempted_skills(database, skill_model, app): 

669 """Test delete_all_attempted_skill method.""" 

670 database.insert( 

671 "attempted_skills", 

672 {"_id": uuid.uuid4().hex, "skill_name": "Test Attempted Skill"}, 

673 ) 

674 

675 with app.app_context(): 

676 with app.test_request_context(): 

677 response = skill_model.delete_all_attempted_skill()[0] 

678 assert response.status_code == 200 

679 assert database.get_all("attempted_skills") == [] 

680 

681 

682def test_upload_skills(database, skill_model, app): 

683 """Test upload_skills method with a valid file.""" 

684 import pandas as pd 

685 from io import BytesIO 

686 

687 data = { 

688 "Skill_Name": ["Uploaded Skill 1", "Uploaded Skill 2"], 

689 "Skill_Description": ["Desc 1", "Desc 2"], 

690 } 

691 df = pd.DataFrame(data) 

692 file = BytesIO() 

693 df.to_excel(file, index=False) 

694 file.seek(0) 

695 file.name = "skills.xlsx" 

696 

697 with app.app_context(): 

698 with app.test_request_context(): 

699 response = skill_model.upload_skills(file)[0] 

700 assert response.status_code == 200 

701 assert ( 

702 database.get_one_by_field("skills", "skill_name", "Uploaded Skill 1") 

703 is not None 

704 ) 

705 assert ( 

706 database.get_one_by_field("skills", "skill_name", "Uploaded Skill 2") 

707 is not None 

708 ) 

709 

710 database.delete_all_by_field("skills", "skill_name", "Uploaded Skill 1") 

711 database.delete_all_by_field("skills", "skill_name", "Uploaded Skill 2") 

712 

713 

714def test_download_all(database, skill_model, app): 

715 """Test download_all method.""" 

716 database.insert( 

717 "skills", 

718 { 

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

720 "skill_name": "Downloadable Skill", 

721 "skill_description": "Desc", 

722 }, 

723 ) 

724 

725 with app.app_context(): 

726 with app.test_request_context(): 

727 response = skill_model.download_all() 

728 assert response.status_code == 200 

729 assert ( 

730 response.mimetype 

731 == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" 

732 ) 

733 

734 database.delete_all_by_field("skills", "skill_name", "Downloadable Skill") 

735 

736 

737def test_find_skill_returns_none(skill_model, app): 

738 """Test find_skill method returns None for non-existent skill.""" 

739 with app.app_context(): 

740 with app.test_request_context(): 

741 assert skill_model.find_skill(skill_name="NonExistent") is None 

742 assert skill_model.find_skill(skill_id="nonexistentid") is None 

743 

744 

745def test_get_list_attempted_skills_empty(database, skill_model, app): 

746 """Test get_list_attempted_skills returns an empty list when no attempted skills exist.""" 

747 database.delete_all("attempted_skills") 

748 

749 with app.app_context(): 

750 with app.test_request_context(): 

751 assert skill_model.get_list_attempted_skills() == []