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

1from mesh.models.orm.factories import ( 

2 ReviewFactory, 

3 SubmissionAuthorFactory, 

4 SubmissionFactory, 

5 SubmissionVersionFactory, 

6 UserFactory, 

7) 

8from mesh.models.orm.review_models import RecommendationValue, Review, ReviewAdditionalFile 

9from mesh.models.orm.submission_models import Submission, SubmissionMainFile, SubmissionState 

10from mesh.models.orm.user_models import User 

11from mesh.models.roles.author import Author 

12from mesh.models.submission_status import SubmissionStatus 

13from mesh.tests.base_test_case import BaseTestCase 

14 

15 

16class AuthorTestCase(BaseTestCase): 

17 used_models = [Review, Submission] 

18 class_used_models = [User] 

19 

20 @classmethod 

21 def setUpClass(cls) -> None: 

22 super().setUpClass() 

23 cls.user_author = UserFactory.create() 

24 cls.user_reviewer = UserFactory.create() 

25 

26 # def test_always_active(self): 

27 # role = Author(self.user_author) 

28 # self.assertTrue(role.active) 

29 

30 def test_submissions(self): 

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

32 submission_2 = SubmissionFactory.create() 

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

34 role = Author(self.user_author) 

35 

36 submissions = role.get_submissions() 

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

38 self.assertIn(submission_1, submissions) 

39 self.assertIn(submission_3, submissions) 

40 

41 role = Author(self.user_author) 

42 self.assertTrue(role.can_access_submission(submission_1)) 

43 self.assertFalse(role.can_access_submission(submission_2)) 

44 self.assertTrue(role.can_access_submission(submission_3)) 

45 

46 def test_can_create_version(self): 

47 submission = SubmissionFactory.create(created_by=self.user_author, author_agreement=True) 

48 role = Author(self.user_author) 

49 # New submission without required author 

50 self.assertFalse(role.can_create_version(submission)) 

51 

52 # New submission with 1 author 

53 SubmissionAuthorFactory.create(submission=submission) 

54 

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

56 self.assertTrue(role.can_create_version(submission)) 

57 

58 # New submission with a 1st version 

59 version = SubmissionVersionFactory.create(submission=submission) 

60 SubmissionMainFile.objects.create(file=self.dummy_file, attached_to=version) 

61 

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

63 self.assertFalse(role.can_create_version(submission)) 

64 

65 # Submitted submission 

66 request = self.dummy_request() 

67 request.user = self.user_author 

68 submission.submit(self.user_author) 

69 

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

71 self.assertFalse(role.can_create_version(submission)) 

72 

73 # Under review submission 

74 submission.state = SubmissionState.ON_REVIEW.value 

75 submission.save() 

76 

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

78 self.assertFalse(role.can_create_version(submission)) 

79 

80 # Revisions requested submission 

81 submission.state = SubmissionState.REVISION_REQUESTED.value 

82 submission.save() 

83 

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

85 self.assertTrue(role.can_create_version(submission)) 

86 version.review_open = False 

87 version.save() 

88 

89 # Revisions requested submission w/ a non-submitted current version 

90 version_2 = SubmissionVersionFactory.create(submission=submission) 

91 SubmissionMainFile.objects.create(file=self.dummy_file, attached_to=version_2) 

92 

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

94 self.assertFalse(role.can_create_version(submission)) 

95 

96 # Revisions submitted submission 

97 submission.submit(self.user_author) 

98 

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

100 self.assertFalse(role.can_create_version(submission)) 

101 

102 def test_can_access_review(self): 

103 role = Author(self.user_author) 

104 

105 submission = SubmissionFactory.create(created_by=self.user_author, author_agreement=True) 

106 SubmissionAuthorFactory.create(submission=submission) 

107 version = SubmissionVersionFactory.create(submission=submission, review_open=True) 

108 SubmissionMainFile.objects.create(file=self.dummy_file, attached_to=version) 

109 

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

111 request = self.dummy_request() 

112 request.user = self.user_author 

113 submission.submit(self.user_author) 

114 

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

116 self.assertFalse(role.can_access_reviews(submission.get_current_version())) 

117 

118 version.review_open = False 

119 version.save() 

120 

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

122 self.assertTrue(role.can_access_reviews(submission.get_current_version())) 

123 

124 review = ReviewFactory.create( 

125 reviewer=self.user_reviewer, 

126 version=version, 

127 accepted=True, 

128 recommendation=RecommendationValue.REVISION_REQUESTED.value, 

129 ) 

130 review_file = ReviewAdditionalFile.objects.create(file=self.dummy_file, attached_to=review) 

131 self.assertFalse(role.can_access_review(submission, review)) 

132 self.assertFalse(role.can_access_review_file(review_file)) 

133 

134 review.submitted = True 

135 review.save() 

136 review = Review.objects.get(pk=review.pk) 

137 self.assertFalse(role.can_access_review_file(review_file)) 

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

139 

140 review_file.author_access = True 

141 review_file.save() 

142 review = Review.objects.get(pk=review.pk) 

143 self.assertTrue(role.can_access_review_file(review_file)) 

144 self.assertTrue(role.can_access_review(submission, review)) 

145 

146 def test_submission_status(self): 

147 """ 

148 The SubmissionStatus only depends on the submission state for the author role. 

149 """ 

150 submission = SubmissionFactory.create(created_by=self.user_author, author_agreement=True) 

151 submission_other = SubmissionFactory.create(author_agreement=True) 

152 role = Author(self.user_author) 

153 

154 status = role.get_submission_status(submission_other) 

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

156 

157 status = role.get_submission_status(submission) 

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

159 

160 submission.state = SubmissionState.SUBMITTED.value 

161 status = role.get_submission_status(submission) 

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

163 

164 submission.state = SubmissionState.ON_REVIEW.value 

165 status = role.get_submission_status(submission) 

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

167 

168 submission.state = SubmissionState.REVISION_REQUESTED.value 

169 status = role.get_submission_status(submission) 

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

171 

172 submission.state = SubmissionState.REVISION_SUBMITTED.value 

173 status = role.get_submission_status(submission) 

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

175 

176 submission.state = SubmissionState.ACCEPTED.value 

177 status = role.get_submission_status(submission) 

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

179 

180 submission.state = SubmissionState.REJECTED.value 

181 status = role.get_submission_status(submission) 

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