Coverage for tests/model_tests/test_course_modules.py: 98%

1"""Tests for the course modules model.""" 

2 

3import os 

4import sys 

5import uuid 

6import pytest 

7from dotenv import load_dotenv 

8 

9# flake8: noqa: F811 

10 

11# Add the root directory to the Python path 

12sys.path.append( 

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

14) 

15from core import shared 

16from core.database_mongo_manager import DatabaseMongoManager 

17 

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

19 

20load_dotenv() 

21 

22 

23@pytest.fixture() 

24def app(): 

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

26 from ...app import app 

27 

28 return app 

29 

30 

31@pytest.fixture() 

32def database(): 

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

34 database = DatabaseMongoManager( 

35 shared.getenv("MONGO_URI"), 

36 shared.getenv("MONGO_DB_TEST", "cs3528_testing"), 

37 ) 

38 modules = database.get_all("modules") 

39 database.delete_all("modules") 

40 

41 yield database 

42 database.delete_all("modules") 

43 if modules: 

44 database.insert_many("modules", modules) 

45 database.connection.close() 

46 

47 

48@pytest.fixture() 

49def module_model(): 

50 """Fixture to create a Module model instance.""" 

51 from course_modules.models import Module 

52 

53 return Module() 

54 

55 

56@pytest.fixture() 

57def sample_module(database): 

58 """Fixture to create a sample module.""" 

59 yield { 

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

61 "module_id": "CS101", 

62 "module_name": "Introduction to CS", 

63 "module_description": "A basic CS course", 

64 } 

65 database.delete_all_by_field("modules", "module_id", "CS101") 

66 

67 

68def test_add_module(database, module_model, app): 

69 """Test add_module method.""" 

70 sample_module = { 

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

72 "module_id": "CS101", 

73 "module_name": "Introduction to CS", 

74 "module_description": "A basic CS course", 

75 } 

76 with app.app_context(): 

77 with app.test_request_context(): 

78 response = module_model.add_module(sample_module)[0] 

79 assert response.status_code == 200 

80 assert database.get_one_by_id("modules", sample_module["_id"]) is not None 

81 database.delete_all_by_field("modules", "module_id", "CS101") 

82 

83 

84def test_get_module_by_id(database, module_model, app, sample_module): 

85 """Test get_module_by_id method.""" 

86 database.insert("modules", sample_module) 

87 with app.app_context(): 

88 with app.test_request_context(): 

89 module = module_model.get_module_by_id(sample_module["module_id"]) 

90 assert module is not None 

91 assert module["module_name"] == "Introduction to CS" 

92 

93 

94def test_get_module_name_by_id(database, module_model, app, sample_module): 

95 """Test get_module_name_by_id method.""" 

96 database.insert("modules", sample_module) 

97 with app.app_context(): 

98 with app.test_request_context(): 

99 module_name = module_model.get_module_name_by_id(sample_module["module_id"]) 

100 assert module_name == "Introduction to CS" 

101 

102 

103def test_update_module_by_uuid(database, module_model, app, sample_module): 

104 """Test update_module_by_uuid method.""" 

105 database.insert("modules", sample_module) 

106 with app.app_context(): 

107 with app.test_request_context(): 

108 response = module_model.update_module_by_uuid( 

109 sample_module["_id"], "CS102", "Advanced CS", "Next level CS" 

110 )[0] 

111 assert response.status_code == 200 

112 updated_module = database.get_one_by_id("modules", sample_module["_id"]) 

113 assert updated_module["module_name"] == "Advanced CS" 

114 

115 

116def test_delete_all_modules(database, module_model, app, sample_module): 

117 """Test delete_all_modules method.""" 

118 students = database.get_all("students") 

119 opportunities = database.get_all("opportunities") 

120 

121 database.delete_all("students") 

122 database.delete_all("opportunities") 

123 

124 database.insert("modules", sample_module) 

125 

126 student1 = { 

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

128 "student_id": "S101", 

129 "student_name": "Alice", 

130 "modules": ["CS101"], 

131 } 

132 opportunity1 = { 

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

134 "title": "Internship", 

135 "employer_id": "E101", 

136 "modules_required": ["CS101"], 

137 } 

138 

139 database.insert("students", student1) 

140 database.insert("opportunities", opportunity1) 

141 

142 with app.app_context(): 

143 with app.test_request_context(): 

144 response = module_model.delete_all_modules()[0] 

145 assert response.status_code == 200 

146 assert database.get_all("modules") == [] 

147 assert database.get_one_by_id("students", student1["_id"]) is not None 

148 assert ( 

149 database.get_one_by_id("opportunities", opportunity1["_id"]) is not None 

150 ) 

151 assert database.get_one_by_id("students", student1["_id"])["modules"] == [] 

152 assert ( 

153 database.get_one_by_id("opportunities", opportunity1["_id"])[ 

154 "modules_required" 

155 ] 

156 == [] 

157 ) 

158 

159 database.delete_all("students") 

160 if students: 

161 database.insert_many("students", students) 

162 database.delete_all("opportunities") 

163 if opportunities: 

164 database.insert_many("opportunities", opportunities) 

165 

166 

167def test_download_all_modules(database, module_model, app): 

168 """Test download_all_modules method.""" 

169 sample_module = { 

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

171 "module_id": "CS101", 

172 "module_name": "Introduction to CS", 

173 "module_description": "A basic CS course", 

174 } 

175 database.insert("modules", sample_module) 

176 with app.app_context(): 

177 with app.test_request_context(): 

178 response = module_model.download_all_modules() 

179 assert ( 

180 response.mimetype 

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

182 ) 

183 

184 

185def test_upload_course_modules(module_model, app, database): 

186 """Test upload_course_modules method with the test spreadsheet.""" 

187 file_path = "tests/data/course_modules_test.xlsx" 

188 assert database.get_all("modules") == [] 

189 

190 with open(file_path, "rb") as file: 

191 with app.app_context(): 

192 with app.test_request_context(): 

193 response = module_model.upload_course_modules(file) 

194 json_response = response[0].get_json() 

195 

196 assert response[1] == 200 

197 assert json_response["message"] == "Uploaded" 

198 

199 

200def test_delete_module_by_id(database, module_model, app, sample_module): 

201 """Test delete_module_by_id method.""" 

202 database.insert("modules", sample_module) 

203 with app.app_context(): 

204 with app.test_request_context(): 

205 response = module_model.delete_module_by_id(sample_module["module_id"])[0] 

206 assert response.status_code == 200 

207 assert database.get_one_by_id("modules", sample_module["_id"]) is None 

208 

209 

210def test_delete_module_by_uuid(database, module_model, app, sample_module): 

211 """Test delete_module_by_uuid method.""" 

212 database.insert("modules", sample_module) 

213 with app.app_context(): 

214 with app.test_request_context(): 

215 response = module_model.delete_module_by_uuid(sample_module["_id"])[0] 

216 assert response.status_code == 200 

217 assert database.get_one_by_id("modules", sample_module["_id"]) is None 

218 

219 

220def test_get_module_by_uuid(database, module_model, app, sample_module): 

221 """Test get_module_by_uuid method.""" 

222 database.insert("modules", sample_module) 

223 with app.app_context(): 

224 with app.test_request_context(): 

225 module = module_model.get_module_by_uuid(sample_module["_id"]) 

226 assert module is not None 

227 assert module["module_name"] == "Introduction to CS" 

228 

229 

230def test_get_modules_map(database, module_model, app, sample_module): 

231 """Test get_modules_map method.""" 

232 database.insert("modules", sample_module) 

233 with app.app_context(): 

234 with app.test_request_context(): 

235 modules_map = module_model.get_modules_map() 

236 assert sample_module["module_id"] in modules_map 

237 assert ( 

238 modules_map[sample_module["module_id"]]["module_name"] 

239 == "Introduction to CS" 

240 ) 

241 

242 

243def test_reset_cache(database, module_model, app): 

244 """Test reset_cache method.""" 

245 from course_modules.models import modules_cache 

246 

247 sample_module = { 

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

249 "module_id": "CS101", 

250 "module_name": "Introduction to CS", 

251 "module_description": "A basic CS course", 

252 } 

253 database.insert("modules", sample_module) 

254 

255 # Ensure the cache is reset 

256 with app.app_context(): 

257 with app.test_request_context(): 

258 module_model.reset_cache() 

259 assert modules_cache["data"] is not None 

260 assert len(modules_cache["data"]) > 0 

261 assert modules_cache["last_updated"] is not None 

262 

263 # Clean up the database 

264 database.delete_all_by_field("modules", "module_id", "CS101")