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

1from mesh.model.roles.author import Author, AuthorRights 

2 

3from ...model.submission_status import SubmissionStatus 

4from ...models.factories import ( 

5 ReviewFactory, 

6 SubmissionAuthorFactory, 

7 SubmissionFactory, 

8 SubmissionVersionFactory, 

9 UserFactory, 

10) 

11from ...models.review_models import RecommendationValue, Review, ReviewAdditionalFile 

12from ...models.submission_models import Submission, SubmissionMainFile, SubmissionState 

13from ...models.user_models import User 

14from ..base_test_case import BaseTestCase 

15 

16 

17class AuthorTestCase(BaseTestCase): 

18 used_models = [Review, Submission] 

19 class_used_models = [User] 

20 

21 @classmethod 

22 def setUpClass(cls) -> None: 

23 super().setUpClass() 

24 cls.user_author = UserFactory.create() 

25 cls.user_reviewer = UserFactory.create() 

26 

27 def test_always_active(self): 

28 author = Author(self.user_author) 

29 self.assertTrue(author.active) 

30 

31 def test_submissions(self): 

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

33 submission_2 = SubmissionFactory.create() 

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

35 author = Author(self.user_author) 

36 

37 submissions = author.rights.submissions 

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

39 self.assertIn(submission_1, submissions) 

40 self.assertIn(submission_3, submissions) 

41 

42 rights = author.rights 

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

44 self.assertFalse(rights.can_access_submission(submission_2)) 

45 self.assertTrue(rights.can_access_submission(submission_3)) 

46 

47 def test_can_create_version(self): 

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

49 rights = AuthorRights(self.user_author) 

50 

51 # New submission without required author 

52 self.assertFalse(rights.can_create_version(submission)) 

53 

54 # New submission with 1 author 

55 SubmissionAuthorFactory.create(submission=submission) 

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

57 self.assertTrue(rights.can_create_version(submission)) 

58 

59 # New submission with a 1st version 

60 version = SubmissionVersionFactory.create(submission=submission) 

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

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

63 self.assertFalse(rights.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 submission = Submission.objects.get(pk=submission.pk) 

70 self.assertFalse(rights.can_create_version(submission)) 

71 

72 # Under review submission 

73 submission.state = SubmissionState.ON_REVIEW.value 

74 submission.save() 

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

76 self.assertFalse(rights.can_create_version(submission)) 

77 

78 # Revisions requested submission 

79 submission.state = SubmissionState.REVISION_REQUESTED.value 

80 submission.save() 

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

82 self.assertTrue(rights.can_create_version(submission)) 

83 version.review_open = False 

84 version.save() 

85 

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

87 version_2 = SubmissionVersionFactory.create(submission=submission) 

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

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

90 self.assertFalse(rights.can_create_version(submission)) 

91 

92 # Revisions submitted submission 

93 submission.submit(self.user_author) 

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

95 self.assertFalse(rights.can_create_version(submission)) 

96 

97 def test_can_access_review(self): 

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

99 SubmissionAuthorFactory.create(submission=submission) 

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

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

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

103 request = self.dummy_request() 

104 request.user = self.user_author 

105 submission.submit(self.user_author) 

106 

107 rights = AuthorRights(self.user_author) 

108 

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

110 self.assertFalse(rights.can_access_reviews(submission.current_version)) # type:ignore 

111 

112 version.review_open = False 

113 version.save() 

114 

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

116 self.assertTrue(rights.can_access_reviews(submission.current_version)) # type:ignore 

117 

118 review = ReviewFactory.create( 

119 reviewer=self.user_reviewer, 

120 version=version, 

121 accepted=True, 

122 recommendation=RecommendationValue.REVISION_REQUESTED.value, 

123 ) 

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

125 self.assertFalse(rights.can_access_review(review)) 

126 self.assertFalse(rights.can_access_review_file(review_file)) 

127 

128 review.submitted = True 

129 review.save() 

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

131 self.assertFalse(rights.can_access_review_file(review_file)) 

132 self.assertFalse(rights.can_access_review(review)) 

133 

134 review_file.author_access = True 

135 review_file.save() 

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

137 self.assertTrue(rights.can_access_review_file(review_file)) 

138 self.assertTrue(rights.can_access_review(review)) 

139 

140 def test_submission_status(self): 

141 """ 

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

143 """ 

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

145 submission_other = SubmissionFactory.create(author_agreement=True) 

146 rights = AuthorRights(self.user_author) 

147 

148 status = rights.get_submission_status(submission_other) 

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

150 

151 status = rights.get_submission_status(submission) 

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

153 

154 submission.state = SubmissionState.SUBMITTED.value 

155 status = rights.get_submission_status(submission) 

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

157 

158 submission.state = SubmissionState.ON_REVIEW.value 

159 status = rights.get_submission_status(submission) 

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

161 

162 submission.state = SubmissionState.REVISION_REQUESTED.value 

163 status = rights.get_submission_status(submission) 

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

165 

166 submission.state = SubmissionState.REVISION_SUBMITTED.value 

167 status = rights.get_submission_status(submission) 

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

169 

170 submission.state = SubmissionState.ACCEPTED.value 

171 status = rights.get_submission_status(submission) 

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

173 

174 submission.state = SubmissionState.REJECTED.value 

175 status = rights.get_submission_status(submission) 

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