Coverage for tests/core_tests/test_deadline_manager.py: 99%

1import sys 

2import os 

3from dotenv import load_dotenv 

4import pytest 

5import datetime 

6 

7# flake8: noqa: F811 

8 

9sys.path.append( 

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

11) 

12 

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

14 

15load_dotenv() 

16from core import shared 

17from core.database_mongo_manager import DatabaseMongoManager 

18from core.deadline_manager import DeadlineManager 

19 

20 

21@pytest.fixture() 

22def database(): 

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

24 

25 DATABASE = DatabaseMongoManager( 

26 shared.getenv("MONGO_URI"), 

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

28 ) 

29 deadlines = DATABASE.get_all("deadline") 

30 DATABASE.delete_all("deadline") 

31 yield DATABASE 

32 DATABASE.delete_all("deadline") 

33 for deadline in deadlines: 

34 DATABASE.insert("deadline", deadline) 

35 

36 # Cleanup code after the test 

37 DATABASE.connection.close() 

38 

39 

40@pytest.fixture 

41def deadline_manager(database, app): 

42 """Create an instance of DeadlineManager using the database fixture.""" 

43 deadlines = database.get_all("deadline") 

44 

45 database.delete_all("deadline") 

46 

47 with app.app_context(): 

48 with app.test_request_context(): 

49 deadline_manager = DeadlineManager() 

50 database.delete_all("deadline") 

51 yield deadline_manager 

52 database.delete_all("deadline") 

53 

54 for deadline in deadlines: 

55 database.insert("deadline", deadline) 

56 

57 

58@pytest.fixture 

59def app(): 

60 from app import app 

61 

62 app.config["TESTING"] = True 

63 return app 

64 

65 

66def test_get_details_deadline(database, deadline_manager): 

67 """Test fetching the details deadline from the database.""" 

68 database.insert("deadline", {"type": 0, "deadline": "2025-03-01"}) 

69 

70 deadline = deadline_manager.get_details_deadline() 

71 assert deadline == "2025-03-01" 

72 

73 

74def test_get_details_deadline_default(database, deadline_manager, app): 

75 """Test default deadline when no deadline exists.""" 

76 

77 expected = (datetime.datetime.now() + datetime.timedelta(weeks=1)).strftime( 

78 "%Y-%m-%d" 

79 ) 

80 with app.app_context(): 

81 with app.test_request_context(): 

82 deadline = deadline_manager.get_details_deadline() 

83 assert deadline == expected 

84 assert ( 

85 database.get_one_by_field("deadline", "type", 0)["deadline"] == expected 

86 ) 

87 

88 

89def test_is_past_details_deadline(deadline_manager, database): 

90 """Test checking if the details deadline has passed.""" 

91 database.insert("deadline", {"type": 0, "deadline": "2024-03-01"}) 

92 

93 # Past date 

94 result = deadline_manager.is_past_details_deadline() 

95 assert result 

96 

97 # Future date 

98 database.update_one_by_field( 

99 "deadline", 

100 "type", 

101 0, 

102 { 

103 "deadline": ( 

104 datetime.datetime.now() + datetime.timedelta(weeks=1) 

105 ).strftime("%Y-%m-%d") 

106 }, 

107 ) 

108 result = deadline_manager.is_past_details_deadline() 

109 assert not result 

110 

111 

112def test_get_student_ranking_deadline(database, deadline_manager): 

113 """Test fetching the student ranking deadline from the database.""" 

114 database.insert("deadline", {"type": 1, "deadline": "2025-04-01"}) 

115 

116 deadline = deadline_manager.get_student_ranking_deadline() 

117 assert deadline == "2025-04-01" 

118 

119 

120def test_get_student_ranking_deadline_default(database, deadline_manager): 

121 """Test default student ranking deadline when no deadline exists.""" 

122 

123 expected = ( 

124 datetime.datetime.strptime(deadline_manager.get_details_deadline(), "%Y-%m-%d") 

125 + datetime.timedelta(weeks=1) 

126 ).strftime("%Y-%m-%d") 

127 

128 deadline = deadline_manager.get_student_ranking_deadline() 

129 assert deadline == expected 

130 assert database.get_one_by_field("deadline", "type", 1)["deadline"] == expected 

131 

132 

133def test_is_past_student_ranking_deadline(deadline_manager, database): 

134 """Test checking if the student ranking deadline has passed.""" 

135 database.insert("deadline", {"type": 1, "deadline": "2024-04-01"}) 

136 

137 # Past date 

138 result = deadline_manager.is_past_student_ranking_deadline() 

139 assert result 

140 

141 # Future date 

142 database.update_one_by_field( 

143 "deadline", 

144 "type", 

145 1, 

146 { 

147 "deadline": ( 

148 datetime.datetime.now() + datetime.timedelta(weeks=1) 

149 ).strftime("%Y-%m-%d") 

150 }, 

151 ) 

152 result = deadline_manager.is_past_student_ranking_deadline() 

153 assert not result 

154 

155 

156def test_get_opportunities_ranking_deadline(database, deadline_manager): 

157 existing_deadline = database.get_one_by_field("deadline", "type", 2) 

158 

159 database.insert("deadline", {"type": 2, "deadline": "2025-05-01"}) 

160 

161 deadline = deadline_manager.get_opportunities_ranking_deadline() 

162 assert deadline == "2025-05-01" 

163 

164 

165def test_get_opportunities_ranking_deadline_default(database, deadline_manager): 

166 """Test default opportunities ranking deadline when no deadline exists.""" 

167 expected = ( 

168 datetime.datetime.strptime( 

169 deadline_manager.get_student_ranking_deadline(), "%Y-%m-%d" 

170 ) 

171 + datetime.timedelta(weeks=1) 

172 ).strftime("%Y-%m-%d") 

173 

174 deadline = deadline_manager.get_opportunities_ranking_deadline() 

175 assert deadline == expected 

176 assert database.get_one_by_field("deadline", "type", 2)["deadline"] == expected 

177 

178 

179def test_is_past_opportunities_ranking_deadline(deadline_manager, database): 

180 """Test checking if the opportunities ranking deadline has passed.""" 

181 database.insert("deadline", {"type": 2, "deadline": "2024-05-01"}) 

182 

183 # Past date 

184 result = deadline_manager.is_past_opportunities_ranking_deadline() 

185 assert result 

186 

187 # Future date 

188 database.update_one_by_field( 

189 "deadline", 

190 "type", 

191 2, 

192 { 

193 "deadline": ( 

194 datetime.datetime.now() + datetime.timedelta(weeks=1) 

195 ).strftime("%Y-%m-%d") 

196 }, 

197 ) 

198 result = deadline_manager.is_past_opportunities_ranking_deadline() 

199 assert not result 

200 

201 

202def test_update_deadlines_invalid_format(deadline_manager, app): 

203 """Test invalid date format in update_deadlines.""" 

204 invalid_format = "invalid-date" 

205 with app.test_request_context(): 

206 response = deadline_manager.update_deadlines( 

207 invalid_format, "2025-03-01", "2025-04-01" 

208 ) 

209 assert response[1] == 400 

210 assert response[0].json["error"] == "Invalid deadline format. Use YYYY-MM-DD." 

211 

212 

213def test_update_deadlines_conflicting_deadlines(deadline_manager, app): 

214 """Test when one deadline is after another (conflicting).""" 

215 with app.test_request_context(): 

216 response = deadline_manager.update_deadlines( 

217 "2025-04-01", "2025-03-01", "2025-05-01" 

218 ) 

219 assert response[1] == 400 

220 assert ( 

221 response[0].json["error"] 

222 == "Details deadline cannot be later than Student Ranking deadline." 

223 ) 

224 

225 

226def test_update_deadlines_success(deadline_manager, database, app): 

227 """Test successful update of deadlines in the database.""" 

228 database.insert("deadline", {"type": 0, "deadline": "2024-03-01"}) 

229 database.insert("deadline", {"type": 1, "deadline": "2024-04-01"}) 

230 database.insert("deadline", {"type": 2, "deadline": "2024-05-01"}) 

231 with app.test_request_context(): 

232 response = deadline_manager.update_deadlines( 

233 "2025-03-01", "2025-04-01", "2025-05-01" 

234 ) 

235 assert response[1] == 200 

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

237 

238 # Check that the deadlines were updated correctly in the database 

239 deadline = database.get_one_by_field("deadline", "type", 0) 

240 assert deadline["deadline"] == "2025-03-01" 

241 

242 deadline = database.get_one_by_field("deadline", "type", 1) 

243 assert deadline["deadline"] == "2025-04-01" 

244 

245 deadline = database.get_one_by_field("deadline", "type", 2) 

246 assert deadline["deadline"] == "2025-05-01"