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

1from django.test import override_settings 

2 

3from mesh.model.roles.reviewer import Reviewer, ReviewerRights 

4 

5from ...app_settings import BlindMode 

6from ...model.submission_status import SubmissionStatus 

7from ...models.factories import ( 

8 ReviewFactory, 

9 SubmissionFactory, 

10 SubmissionVersionFactory, 

11 UserFactory, 

12) 

13from ...models.review_models import Review 

14from ...models.submission_models import Submission, SubmissionState 

15from ...models.user_models import User 

16from ..base_test_case import BaseTestCase 

17 

18 

19class ReviewerTestCase(BaseTestCase): 

20 used_models = [Review, Submission] 

21 class_used_models = [User] 

22 

23 @classmethod 

24 def setUpClass(cls) -> None: 

25 super().setUpClass() 

26 cls.user_author = UserFactory.create() 

27 cls.user_reviewer = UserFactory.create() 

28 

29 def test_submissions(self): 

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

31 version_1 = SubmissionVersionFactory.create(submission=submission_1) 

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

33 version_2 = SubmissionVersionFactory.create(submission=submission_2) 

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

35 version_3 = SubmissionVersionFactory.create(submission=submission_3) 

36 

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

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

39 review_3 = ReviewFactory.create(version=version_3) 

40 

41 role = Reviewer(self.user_reviewer) 

42 self.assertTrue(role.active) 

43 

44 rights = role.rights 

45 self.assertEqual(len(rights.submissions), 2) 

46 self.assertIn(submission_1, rights.submissions) 

47 self.assertIn(submission_2, rights.submissions) 

48 

49 self.assertEqual(len(rights.reviews), 2) 

50 self.assertIn(review_1, rights.reviews) 

51 self.assertIn(review_2, rights.reviews) 

52 

53 self.assertTrue(rights.can_access_submission(submission_1)) 

54 self.assertTrue(rights.can_access_submission(submission_2)) 

55 self.assertFalse(rights.can_access_submission(submission_3)) 

56 

57 self.assertTrue(rights.can_access_version(version_1)) 

58 self.assertTrue(rights.can_access_version(version_2)) 

59 self.assertFalse(rights.can_access_version(version_3)) 

60 

61 self.assertTrue(rights.can_access_review(review_1)) 

62 self.assertTrue(rights.can_access_review(review_2)) 

63 self.assertFalse(rights.can_access_review(review_3)) 

64 

65 def test_get_current_open_review(self): 

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

67 version_1 = SubmissionVersionFactory.create( 

68 submission=submission, submitted=True, review_open=True 

69 ) 

70 

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

72 

73 rights = ReviewerRights(self.user_reviewer) 

74 self.assertEqual(review_1, rights.get_current_open_review(version_1)) 

75 

76 version_1.review_open = False 

77 version_1.save() 

78 rights = ReviewerRights(self.user_reviewer) 

79 self.assertIsNone(rights.get_current_open_review(version_1)) 

80 

81 # Refresh cache 

82 submission = Submission.objects.get(pk=submission.pk) 

83 version_2 = SubmissionVersionFactory.create( 

84 submission=submission, submitted=True, review_open=True 

85 ) 

86 rights = ReviewerRights(self.user_reviewer) 

87 self.assertIsNone(rights.get_current_open_review(version_1)) 

88 self.assertIsNone(rights.get_current_open_review(version_2)) 

89 

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

91 rights = ReviewerRights(self.user_reviewer) 

92 self.assertIsNone(rights.get_current_open_review(version_1)) 

93 self.assertEqual(review_2, rights.get_current_open_review(version_2)) 

94 

95 review_2.submitted = True 

96 review_2.save() 

97 rights = ReviewerRights(self.user_reviewer) 

98 self.assertIsNone(rights.get_current_open_review(version_1)) 

99 self.assertIsNone(rights.get_current_open_review(version_2)) 

100 

101 def test_can_edit_review(self): 

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

103 version = SubmissionVersionFactory.create( 

104 submission=submission, submitted=True, review_open=True 

105 ) 

106 

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

108 rights = ReviewerRights(self.user_reviewer) 

109 

110 self.assertTrue(rights.can_edit_review(review)) 

111 

112 version.review_open = False 

113 version.save() 

114 rights = ReviewerRights(self.user_reviewer) 

115 self.assertFalse(rights.can_edit_review(review)) 

116 

117 version.review_open = True 

118 version.save() 

119 review.submitted = True 

120 review.save() 

121 rights = ReviewerRights(self.user_reviewer) 

122 self.assertFalse(rights.can_edit_review(review)) 

123 

124 @override_settings(MESH_BLIND_MODE=BlindMode.NO_BLIND.value) 

125 def test_can_access_submission_author(self): 

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

127 version = SubmissionVersionFactory.create( 

128 submission=submission, submitted=True, review_open=True 

129 ) 

130 

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

132 rights = ReviewerRights(self.user_reviewer) 

133 

134 self.assertTrue(rights.can_access_submission_author(submission)) 

135 

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

137 self.assertTrue(rights.can_access_submission_author(submission)) 

138 

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

140 self.assertFalse(rights.can_access_submission_author(submission)) 

141 

142 def test_submission_status(self): 

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

144 version = SubmissionVersionFactory.create( 

145 submission=submission, submitted=True, review_open=True 

146 ) 

147 rights = ReviewerRights(self.user_reviewer) 

148 

149 # No access to the submission 

150 status = rights.get_submission_status(submission) 

151 self.assertEqual(status.status, SubmissionStatus.ERROR) 

152 

153 # A review request for the current version 

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

155 rights = ReviewerRights(self.user_reviewer) 

156 submission = Submission.objects.get(pk=submission.pk) 

157 status = rights.get_submission_status(submission) 

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

159 

160 # An accepted review request for the current version 

161 review.accepted = True 

162 review.save() 

163 rights = ReviewerRights(self.user_reviewer) 

164 submission = Submission.objects.get(pk=submission.pk) 

165 status = rights.get_submission_status(submission) 

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

167 

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

169 version.review_open = False 

170 version.save() 

171 rights = ReviewerRights(self.user_reviewer) 

172 submission = Submission.objects.get(pk=submission.pk) 

173 status = rights.get_submission_status(submission) 

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

175 

176 # Re-open review process 

177 version.review_open = True 

178 version.save() 

179 rights = ReviewerRights(self.user_reviewer) 

180 submission = Submission.objects.get(pk=submission.pk) 

181 status = rights.get_submission_status(submission) 

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

183 

184 # An declined review request for the current version 

185 review.accepted = False 

186 review.save() 

187 rights = ReviewerRights(self.user_reviewer) 

188 submission = Submission.objects.get(pk=submission.pk) 

189 status = rights.get_submission_status(submission) 

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

191 

192 # A submitted review for the current version 

193 review.submitted = True 

194 review.save() 

195 rights = ReviewerRights(self.user_reviewer) 

196 submission = Submission.objects.get(pk=submission.pk) 

197 status = rights.get_submission_status(submission) 

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

199 

200 # New version with no review attached. 

201 version.review_open = False 

202 version.save() 

203 version = SubmissionVersionFactory.create( 

204 submission=submission, submitted=True, review_open=True 

205 ) 

206 rights = ReviewerRights(self.user_reviewer) 

207 submission = Submission.objects.get(pk=submission.pk) 

208 status = rights.get_submission_status(submission) 

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

210 

211 # Accepted submission 

212 submission.state = SubmissionState.ACCEPTED.value 

213 submission.save() 

214 rights = ReviewerRights(self.user_reviewer) 

215 submission = Submission.objects.get(pk=submission.pk) 

216 status = rights.get_submission_status(submission) 

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

218 

219 # Rejected submission 

220 submission.state = SubmissionState.REJECTED.value 

221 submission.save() 

222 rights = ReviewerRights(self.user_reviewer) 

223 submission = Submission.objects.get(pk=submission.pk) 

224 status = rights.get_submission_status(submission) 

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