Coverage for src / mesh / tests / roles / test_reviewer.py: 100%

1from django.test import override_settings 

2 

3from mesh.app_settings import BlindMode 

4from mesh.models.orm.factories import ( 

5 ReviewFactory, 

6 SubmissionFactory, 

7 SubmissionVersionFactory, 

8 UserFactory, 

9) 

10from mesh.models.orm.review_models import Review 

11from mesh.models.orm.submission_models import Submission, SubmissionState 

12from mesh.models.orm.user_models import User 

13from mesh.models.roles.reviewer import Reviewer 

14from mesh.models.submission_status import SubmissionStatus 

15from mesh.tests.base_test_case import BaseTestCase 

16 

17 

18class ReviewerTestCase(BaseTestCase): 

19 used_models = [Review, Submission] 

20 class_used_models = [User] 

21 

22 @classmethod 

23 def setUpClass(cls) -> None: 

24 super().setUpClass() 

25 cls.user_author = UserFactory.create() 

26 cls.user_reviewer = UserFactory.create() 

27 

28 def test_submissions(self): 

29 submission_1 = SubmissionFactory.create(created_by=self.user_author) 

30 version_1 = SubmissionVersionFactory.create(submission=submission_1) 

31 submission_2 = SubmissionFactory.create(created_by=self.user_author) 

32 version_2 = SubmissionVersionFactory.create(submission=submission_2) 

33 submission_3 = SubmissionFactory.create(created_by=self.user_reviewer) 

34 version_3 = SubmissionVersionFactory.create(submission=submission_3) 

35 

36 review_1 = ReviewFactory.create(version=version_1, reviewer=self.user_reviewer) 

37 review_2 = ReviewFactory.create(version=version_2, reviewer=self.user_reviewer) 

38 review_3 = ReviewFactory.create(version=version_3) 

39 

40 role = Reviewer(self.user_reviewer) 

41 # self.assertTrue(role.active) 

42 

43 submissions = role.get_submissions() 

44 self.assertEqual(len(submissions), 2) 

45 self.assertIn(submission_1, submissions) 

46 self.assertIn(submission_2, submissions) 

47 

48 censored_submission_1 = next(s for s in submissions if s == submission_1) 

49 version_censored_1 = next( 

50 v for v in censored_submission_1.versions_censored if v == version_1 

51 ) 

52 review_censored_1 = next(r for r in version_censored_1.reviews_censored if r == review_1) 

53 censored_submission_2 = next(s for s in submissions if s == submission_2) 

54 version_censored_2 = next( 

55 v for v in censored_submission_2.versions_censored if v == version_2 

56 ) 

57 review_censored_2 = next(r for r in version_censored_2.reviews_censored if r == review_2) 

58 

59 self.assertTrue(role.can_access_submission(censored_submission_1)) 

60 self.assertTrue(role.can_access_submission(censored_submission_2)) 

61 self.assertFalse(role.can_access_submission(submission_3)) 

62 

63 self.assertTrue(role.can_access_version(version_censored_1)) 

64 self.assertTrue(role.can_access_version(version_censored_2)) 

65 self.assertFalse(role.can_access_version(version_3)) 

66 

67 self.assertTrue(role.can_access_review(submission_1, review_censored_1)) 

68 self.assertTrue(role.can_access_review(submission_2, review_censored_2)) 

69 self.assertFalse(role.can_access_review(submission_3, review_3)) 

70 

71 def test_get_current_open_review(self): 

72 submission = SubmissionFactory.create(created_by=self.user_author) 

73 version_1 = SubmissionVersionFactory.create( 

74 submission=submission, submitted=True, review_open=True 

75 ) 

76 

77 review_1 = ReviewFactory.create(reviewer=self.user_reviewer, version=version_1) 

78 

79 role = Reviewer(self.user_reviewer) 

80 

81 submission = role.get_submissions().get(pk=submission.pk) 

82 version_censored_1 = next(v for v in submission.versions_censored if v == version_1) 

83 self.assertEqual(review_1, role.get_current_open_review(version_censored_1)) 

84 

85 version_1.review_open = False 

86 version_1.save() 

87 

88 submission = role.get_submissions().get(pk=submission.pk) 

89 version_censored_1 = next(v for v in submission.versions_censored if v == version_1) 

90 self.assertIsNone(role.get_current_open_review(version_censored_1)) 

91 

92 # Refresh cache 

93 version_2 = SubmissionVersionFactory.create( 

94 submission=submission, submitted=True, review_open=True 

95 ) 

96 

97 submission = role.get_submissions().get(pk=submission.pk) 

98 version_censored_1 = next(v for v in submission.versions_censored if v == version_1) 

99 with self.assertRaises(StopIteration): 

100 next(v for v in submission.versions_censored if v == version_2) 

101 self.assertIsNone(role.get_current_open_review(version_censored_1)) 

102 # self.assertIsNone(role.get_current_open_review(version_censored_2)) 

103 

104 review_2 = ReviewFactory.create(reviewer=self.user_reviewer, version=version_2) 

105 

106 submission = role.get_submissions().get(pk=submission.pk) 

107 version_censored_2 = next(v for v in submission.versions_censored if v == version_2) 

108 self.assertIsNone(role.get_current_open_review(version_censored_1)) 

109 self.assertEqual(review_2, role.get_current_open_review(version_censored_2)) 

110 

111 review_2.submitted = True 

112 review_2.save() 

113 

114 submission = role.get_submissions().get(pk=submission.pk) 

115 version_censored_2 = next(v for v in submission.versions_censored if v == version_2) 

116 self.assertIsNone(role.get_current_open_review(version_censored_1)) 

117 self.assertIsNone(role.get_current_open_review(version_censored_2)) 

118 

119 def test_can_edit_review(self): 

120 submission = SubmissionFactory.create(created_by=self.user_author) 

121 version = SubmissionVersionFactory.create( 

122 submission=submission, submitted=True, review_open=True 

123 ) 

124 

125 review = ReviewFactory.create(reviewer=self.user_reviewer, version=version) 

126 role = Reviewer(self.user_reviewer) 

127 

128 self.assertTrue(role.can_edit_review(submission, review)) 

129 

130 version.review_open = False 

131 version.save() 

132 self.assertFalse(role.can_edit_review(submission, review)) 

133 

134 version.review_open = True 

135 version.save() 

136 review.submitted = True 

137 review.save() 

138 self.assertFalse(role.can_edit_review(submission, review)) 

139 

140 def test_can_access_submission_author(self): 

141 submission = SubmissionFactory.create(created_by=self.user_author) 

142 version = SubmissionVersionFactory.create( 

143 submission=submission, submitted=True, review_open=True 

144 ) 

145 

146 ReviewFactory.create(reviewer=self.user_reviewer, version=version) 

147 

148 with override_settings(MESH_BLIND_MODE=BlindMode.SINGLE_BLIND.value): 

149 # HACK : We cannot test our custom query with sqlite... 

150 # Knowing that it crashes should be enough to ensure the StrAggr gets at least parsed 

151 role = Reviewer(self.user_reviewer) 

152 submission = role.get_submissions().get(pk=submission.pk) 

153 

154 self.assertEqual(len(submission.authors_censored), 0) 

155 

156 with override_settings(MESH_BLIND_MODE=BlindMode.SINGLE_BLIND.value): 

157 role = Reviewer(self.user_reviewer) 

158 

159 submission = role.get_submissions().get(pk=submission.pk) 

160 

161 self.assertEqual(len(submission.authors_censored), 0) 

162 

163 with override_settings(MESH_BLIND_MODE=BlindMode.DOUBLE_BLIND.value): 

164 role = Reviewer(self.user_reviewer) 

165 submission = role.get_submissions().get(pk=submission.pk) 

166 self.assertEqual(submission.authors_string, "**** ****") 

167 self.assertEqual(len(submission.authors_censored), 0) 

168 

169 def test_submission_status(self): 

170 submission = SubmissionFactory.create(created_by=self.user_author) 

171 version = SubmissionVersionFactory.create( 

172 submission=submission, submitted=True, review_open=True 

173 ) 

174 role = Reviewer(self.user_reviewer) 

175 

176 # No access to the submission 

177 with self.assertRaises(Submission.DoesNotExist): 

178 submission = role.get_submissions().get(pk=submission.pk) 

179 # status = role.get_submission_status(submission) 

180 # self.assertEqual(status.status, SubmissionStatus.ERROR) 

181 

182 # A review request for the current version 

183 review = ReviewFactory.create(reviewer=self.user_reviewer, version=version) 

184 

185 submission = role.get_submissions().get(pk=submission.pk) 

186 status = role.get_submission_status(submission) 

187 self.assertEqual(status.status, SubmissionStatus.TODO) 

188 

189 # An accepted review request for the current version 

190 review.accepted = True 

191 review.save() 

192 

193 submission = role.get_submissions().get(pk=submission.pk) 

194 status = role.get_submission_status(submission) 

195 self.assertEqual(status.status, SubmissionStatus.TODO) 

196 

197 # An accepted review request for the current version with review process closed 

198 version.review_open = False 

199 version.save() 

200 

201 submission = role.get_submissions().get(pk=submission.pk) 

202 status = role.get_submission_status(submission) 

203 self.assertEqual(status.status, SubmissionStatus.WAITING) 

204 

205 # Re-open review process 

206 version.review_open = True 

207 version.save() 

208 

209 submission = role.get_submissions().get(pk=submission.pk) 

210 status = role.get_submission_status(submission) 

211 self.assertEqual(status.status, SubmissionStatus.TODO) 

212 

213 # An declined review request for the current version 

214 review.accepted = False 

215 review.save() 

216 

217 submission = role.get_submissions().get(pk=submission.pk) 

218 status = role.get_submission_status(submission) 

219 self.assertEqual(status.status, SubmissionStatus.DONE) 

220 

221 # A submitted review for the current version 

222 review.submitted = True 

223 review.save() 

224 

225 submission = role.get_submissions().get(pk=submission.pk) 

226 status = role.get_submission_status(submission) 

227 self.assertEqual(status.status, SubmissionStatus.WAITING) 

228 

229 # New version with no review attached. 

230 version.review_open = False 

231 version.save() 

232 version = SubmissionVersionFactory.create( 

233 submission=submission, submitted=True, review_open=True 

234 ) 

235 

236 submission = role.get_submissions().get(pk=submission.pk) 

237 status = role.get_submission_status(submission) 

238 self.assertEqual(status.status, SubmissionStatus.WAITING) 

239 

240 # Accepted submission 

241 submission.state = SubmissionState.ACCEPTED.value 

242 submission.save() 

243 

244 submission = role.get_submissions().get(pk=submission.pk) 

245 status = role.get_submission_status(submission) 

246 self.assertEqual(status.status, SubmissionStatus.DONE) 

247 

248 # Rejected submission 

249 submission.state = SubmissionState.REJECTED.value 

250 submission.save() 

251 

252 submission = role.get_submissions().get(pk=submission.pk) 

253 status = role.get_submission_status(submission) 

254 self.assertEqual(status.status, SubmissionStatus.DONE)