Coverage for src / mesh / tests / workflow / helpers / reviewer_request_helpers.py: 96%

1import logging 

2from typing import TYPE_CHECKING 

3 

4from django.urls import reverse 

5 

6from mesh.models.orm.review_models import RecommendationValue, ReviewState 

7from mesh.models.submission_status import SubmissionStatus 

8from mesh.tests.workflow.helpers.base_helpers import ( 

9 assert_review_recommendation, 

10 assert_review_state, 

11 assert_submission_status, 

12 check_submission_detail_page, 

13 get_review, 

14 get_reviewer_user, 

15) 

16 

17if TYPE_CHECKING: 

18 from mesh.models.review_models import Review 

19logger = logging.getLogger(__name__) 

20 

21 

22def get_submission_page_with_token(client, token_url, expected_status_code=302): 

23 response = client.get(token_url) 

24 assert response.status_code == expected_status_code, ( 

25 f"Error on get_submission_page_with_token response status code, expected {expected_status_code}, got {response.status_code}" 

26 ) 

27 

28 

29def access_decline_review_page(client, review: "Review", expected_status_code=200): 

30 response = client.get( 

31 reverse( 

32 "mesh:review_decline", 

33 kwargs={ 

34 "submission_pk": review.version.submission.pk, 

35 "version_pk": review.version.pk, 

36 "review_pk": review.pk, 

37 }, 

38 ), 

39 ) 

40 assert response.status_code == expected_status_code, ( 

41 f"Error on access_decline_review_page response status code, expected {expected_status_code}, got {response.status_code}" 

42 ) 

43 

44 

45def decline_review( 

46 client, 

47 review: "Review", 

48 decline_comment="No thanks", 

49 reviewer_profile=None, 

50 expected_status_code=302, 

51): 

52 response = client.post( 

53 reverse( 

54 "mesh:review_decline", 

55 kwargs={ 

56 "submission_pk": review.version.submission.pk, 

57 "version_pk": review.version.pk, 

58 "review_pk": review.pk, 

59 }, 

60 ), 

61 data={"accept_comment": decline_comment}, 

62 ) 

63 assert response.status_code == expected_status_code, ( 

64 f"Error on decline_review response status code, expected {expected_status_code}, got {response.status_code}" 

65 ) 

66 

67 

68def access_accept_review_page(client, review: "Review", expected_status_code=200): 

69 response = client.get( 

70 reverse( 

71 "mesh:review_accept", 

72 kwargs={ 

73 "submission_pk": review.version.submission.pk, 

74 "version_pk": review.version.pk, 

75 "review_pk": review.pk, 

76 }, 

77 ), 

78 ) 

79 assert response.status_code == expected_status_code, ( 

80 f"Error on access_accept_review_page response status code, expected {expected_status_code}, got {response.status_code}" 

81 ) 

82 

83 

84def accept_review( 

85 client, review: "Review", comment="Challenge accepted", expected_status_code=302 

86): 

87 response = client.post( 

88 reverse( 

89 "mesh:review_accept", 

90 kwargs={ 

91 "submission_pk": review.version.submission.pk, 

92 "version_pk": review.version.pk, 

93 "review_pk": review.pk, 

94 }, 

95 ), 

96 data={"accept_comment": comment}, 

97 ) 

98 assert response.status_code == expected_status_code, ( 

99 f"Error on accept_review response status code, expected {expected_status_code}, got {response.status_code}" 

100 ) 

101 

102 

103def accept_review_invite_with_token_workflow(client, submission_pk, token_url): 

104 get_submission_page_with_token(client, token_url) 

105 review = get_review(submission_pk) 

106 access_accept_review_page(client, review) 

107 accept_review(client, review) 

108 assert_review_state(submission_pk=submission_pk, expected_review_state=ReviewState.PENDING) 

109 

110 

111def decline_review_invite_with_token_workflow(client, submission_pk, token_url, reviewer_profile): 

112 get_submission_page_with_token(client, token_url) 

113 review = get_review(submission_pk) 

114 access_decline_review_page(client, review) 

115 decline_review(client, review, reviewer_profile=reviewer_profile) 

116 assert_review_state(submission_pk=submission_pk, expected_review_state=ReviewState.DECLINED) 

117 

118 

119def accept_review_invite_workflow(client, submission_pk): 

120 review = get_review(submission_pk) 

121 access_accept_review_page(client, review) 

122 accept_review(client, review) 

123 assert_review_state(submission_pk=submission_pk, expected_review_state=ReviewState.PENDING) 

124 

125 

126def get_review_update_page(client, review: "Review", expected_status_code=200): 

127 response = client.get( 

128 reverse( 

129 "mesh:review_update", 

130 kwargs={ 

131 "submission_pk": review.version.submission.pk, 

132 "version_pk": review.version.pk, 

133 "review_pk": review.pk, 

134 }, 

135 ), 

136 ) 

137 assert response.status_code == expected_status_code, ( 

138 f"Error on get_review_update_page response status code, expected {expected_status_code}, got {response.status_code}" 

139 ) 

140 

141 

142def make_review( 

143 client, 

144 review: "Review", 

145 recommendation, 

146 comment="Some review comment", 

147 expected_status_code=302, 

148): 

149 response = client.post( 

150 reverse( 

151 "mesh:review_update", 

152 kwargs={ 

153 "submission_pk": review.version.submission.pk, 

154 "version_pk": review.version.pk, 

155 "review_pk": review.pk, 

156 }, 

157 ), 

158 data={ 

159 "recommendation": recommendation, 

160 "comment": comment, 

161 }, 

162 ) 

163 assert response.status_code == expected_status_code, ( 

164 f"Error on make_review response status code, expected {expected_status_code}, got {response.status_code}" 

165 ) 

166 

167 

168def confirm_review(client, review: "Review", confirm="on", expected_status_code=302): 

169 response = client.post( 

170 reverse( 

171 "mesh:review_confirm", 

172 kwargs={ 

173 "submission_pk": review.version.submission.pk, 

174 "version_pk": review.version.pk, 

175 "review_pk": review.pk, 

176 }, 

177 ), 

178 data={ 

179 "confirm": confirm, 

180 }, 

181 ) 

182 assert response.status_code == expected_status_code, ( 

183 f"Error on confirm_review response status code, expected {expected_status_code}, got {response.status_code}" 

184 ) 

185 

186 

187def access_review_details(client, review, expected_status_code=200): 

188 response = client.get( 

189 reverse( 

190 "mesh:review_details", 

191 kwargs={ 

192 "submission_pk": review.version.submission.pk, 

193 "version_pk": review.version.pk, 

194 "review_pk": review.pk, 

195 }, 

196 ), 

197 ) 

198 assert response.status_code == expected_status_code, ( 

199 f"Error on confirm_review response status code, expected {expected_status_code}, got {response.status_code}" 

200 ) 

201 

202 

203def recommend_accept_submission_workflow(client, submission_pk, reviewer_email): 

204 check_submission_detail_page(client, submission_pk) 

205 

206 reviewer_user = get_reviewer_user(reviewer_email) 

207 assert_submission_status( 

208 reviewer_user, 

209 submission_pk=submission_pk, 

210 expected_status=SubmissionStatus.TODO, 

211 ) 

212 review = get_review(submission_pk) 

213 

214 get_review_update_page(client, review) 

215 # status : todo 

216 make_review(client, review, recommendation="accepted") 

217 confirm_review(client, review) 

218 # status : done 

219 assert_review_recommendation( 

220 submission_pk, expected_review_recommendation=RecommendationValue.ACCEPTED 

221 ) 

222 assert_review_state(submission_pk=submission_pk, expected_review_state=ReviewState.SUBMITTED) 

223 assert_submission_status( 

224 reviewer_user, 

225 submission_pk=submission_pk, 

226 expected_status=SubmissionStatus.WAITING, 

227 ) 

228 

229 

230def recommend_reject_submission_workflow(client, submission_pk, reviewer_email): 

231 check_submission_detail_page(client, submission_pk) 

232 reviewer_user = get_reviewer_user(reviewer_email) 

233 assert_submission_status( 

234 reviewer_user, 

235 submission_pk=submission_pk, 

236 expected_status=SubmissionStatus.TODO, 

237 ) 

238 review = get_review(submission_pk) 

239 get_review_update_page(client, review) 

240 make_review(client, review, recommendation="rejected") 

241 confirm_review(client, review) 

242 assert_review_recommendation( 

243 submission_pk, expected_review_recommendation=RecommendationValue.REJECTED 

244 ) 

245 assert_review_state(submission_pk=submission_pk, expected_review_state=ReviewState.SUBMITTED) 

246 assert_submission_status( 

247 user=reviewer_user, 

248 submission_pk=submission_pk, 

249 expected_status=SubmissionStatus.WAITING, 

250 ) 

251 

252 

253def recommend_revision_workflow(client, submission_pk, reviewer_email): 

254 check_submission_detail_page(client, submission_pk) 

255 reviewer_user = get_reviewer_user(reviewer_email) 

256 assert_submission_status( 

257 user=reviewer_user, 

258 submission_pk=submission_pk, 

259 expected_status=SubmissionStatus.TODO, 

260 ) 

261 review = get_review(submission_pk) 

262 get_review_update_page(client, review) 

263 make_review(client, review, recommendation="rev_requested") 

264 confirm_review(client, review) 

265 assert_review_recommendation( 

266 submission_pk, expected_review_recommendation=RecommendationValue.REVISION_REQUESTED 

267 ) 

268 assert_review_state(submission_pk=submission_pk, expected_review_state=ReviewState.SUBMITTED) 

269 assert_submission_status( 

270 reviewer_user, 

271 submission_pk=submission_pk, 

272 expected_status=SubmissionStatus.WAITING, 

273 ) 

274 

275 return review 

276 

277 

278def recommend_resubmission_workflow(client, submission_pk, reviewer_email): 

279 check_submission_detail_page(client, submission_pk) 

280 reviewer_user = get_reviewer_user(reviewer_email) 

281 

282 assert_submission_status( 

283 reviewer_user, 

284 submission_pk=submission_pk, 

285 expected_status=SubmissionStatus.TODO, 

286 ) 

287 review = get_review(submission_pk) 

288 get_review_update_page(client, review) 

289 make_review(client, review, recommendation="resubmit") 

290 confirm_review(client, review) 

291 assert_review_recommendation( 

292 submission_pk, expected_review_recommendation=RecommendationValue.RESUBMIT_SOMEWHERE_ELSE 

293 ) 

294 assert_review_state(submission_pk=submission_pk, expected_review_state=ReviewState.SUBMITTED) 

295 reviewer_user = get_reviewer_user(reviewer_email) 

296 assert_submission_status( 

297 reviewer_user, 

298 submission_pk=submission_pk, 

299 expected_status=SubmissionStatus.WAITING, 

300 )