def test_add_students_and_workgroups_to_context(self):
context = {}
workgroup_value = [
WorkgroupDetails(id=1, users=[{'id': 1}]),
WorkgroupDetails(id=2, users=[{'id': 2}, {'id': 3}])
]
users_value = ['user_sentinel']
self.make_patch(type(self.block), 'workgroups', mock.PropertyMock(return_value=workgroup_value))
self.make_patch(type(self.block), 'all_users_in_workgroups', mock.PropertyMock(return_value=users_value))
self.block._add_students_and_workgroups_to_context(context)
self.assertEqual(context[Constants.TARGET_WORKGROUPS], workgroup_value)
self.assertEqual(context[Constants.TARGET_STUDENTS], users_value)
self.assertEqual(context[Constants.FILTERED_STUDENTS], set())
def test_users_in_workgroups(self, workgroup_ids, expected_user_ids):
workgroups = {
1: WorkgroupDetails(id=1, users=[{'id': 1}]),
2: WorkgroupDetails(id=2, users=[{'id': 2}, {'id': 3}])
}
def _get_workgroup_by_id(workgroup_id):
return workgroups.get(workgroup_id, None)
self.block.project_details.workgroups = workgroup_ids
self.project_api_mock.get_workgroup_by_id.side_effect = _get_workgroup_by_id
users = self.block.all_users_in_workgroups
self.assertEqual([user.id for user in users], expected_user_ids)
def get_workgroup_by_id(self, group_id):
"""
:param int group_id: Group ID
:rtype: WorkgroupDetails
"""
response = self.send_request(GET, (WORKGROUP_API, group_id))
return WorkgroupDetails(**response)
def get_workgroups_for_assignment(self, assignment_id):
"""
:param int assignment_id: Assignment ID
:rtype: list[WorkgroupDetails]
"""
workgroups = self.send_request(
GET, (GROUP_API, assignment_id, 'workgroups'),
no_trailing_slash=True)
return [WorkgroupDetails(**item) for item in workgroups["results"]]
def test_is_group_member(self, user_id, group_members, is_member):
self.user_id_mock.return_value = user_id
with mock.patch.object(WorkgroupAwareXBlockMixin, 'workgroup',
mock.PropertyMock()) as patched_workgroup:
patched_workgroup.return_value = WorkgroupDetails(
id=0, users=[{
"id": u_id
} for u_id in group_members])
self.assertEqual(self.block.is_group_member, is_member)
def setUp(self):
super(TestGroupProjectSubmissionXBlock, self).setUp()
self.project_api_mock = mock.create_autospec(TypedProjectAPI)
self.make_patch(self.block_to_test, 'project_api',
mock.PropertyMock(return_value=self.project_api_mock))
user_details = mock.Mock(user_label='Test label')
self.block_to_test.project_api.get_user_details = mock.Mock(
spec=TypedProjectAPI.get_user_details, return_value=user_details)
self.project_api_mock.get_latest_workgroup_submissions_by_id = mock.Mock(
return_value={})
self.stage_mock.available_now = True
self.stage_mock.activity = mock.Mock()
self.stage_mock.activity.user_id = self.user_id
self.stage_mock.activity.workgroup = WorkgroupDetails(id=self.group_id)
self.stage_mock.activity.course_id = self.course_id
class WorkgroupAwareXBlockMixin(AuthXBlockMixin, UserAwareXBlockMixin,
CourseAwareXBlockMixin):
"""
Gets current user workgroup, respecting TA review
"""
FALLBACK_WORKGROUP = WorkgroupDetails(id=0, users=[])
@property
def group_id(self):
"""
:rtype: int
"""
return self.workgroup.id
@property
def is_group_member(self):
"""
:rtype: bool
"""
return self.user_id in [u.id for u in self.workgroup.users]
@property
def workgroup(self):
"""
:rtype: WorkgroupDetails
"""
try:
user_prefs = self.user_preferences
if UserAwareXBlockMixin.TA_REVIEW_KEY in user_prefs:
self.check_ta_access(self.user_id, self.course_id)
return self.project_api.get_workgroup_by_id(
user_prefs[UserAwareXBlockMixin.TA_REVIEW_KEY])
else:
workgroup = self.project_api.get_user_workgroup_for_course(
self.user_id, self.course_id)
if workgroup is None:
return self.FALLBACK_WORKGROUP
return workgroup
except GroupworkAccessDeniedError:
raise
except ApiError as exception:
log.exception(exception)
return self.FALLBACK_WORKGROUP
def test_review_status(self, groups, questions, reviews, expected_result):
def get_reviews(group_id, _component_id):
return reviews.get(group_id, [])
expected_calls = [
mock.call(group_id, self.block.activity_content_id)
for group_id in groups
]
self.project_api_mock.get_workgroup_review_items_for_group.side_effect = get_reviews
with patch_obj(self.block_to_test, 'review_subjects', mock.PropertyMock()) as patched_review_subjects, \
patch_obj(self.block_to_test, 'required_questions', mock.PropertyMock()) as patched_questions:
patched_review_subjects.return_value = [
WorkgroupDetails(id=rev_id) for rev_id in groups
]
patched_questions.return_value = [
make_question(q_id, 'irrelevant') for q_id in questions
]
self.assertEqual(self.block.review_status(), expected_result)
self.assertEqual(
self.project_api_mock.get_workgroup_review_items_for_group.
mock_calls, expected_calls)
def make_workgroup(user_ids):
return WorkgroupDetails(users=[{
"id": user_id,
"username": "******" + str(user_id),
"email": "{0}@example.com".format(user_id)
} for user_id in user_ids])
def make_workgroup(workgroup_id, users=None):
if not users:
users = []
return WorkgroupDetails(id=workgroup_id, users=users)
id=TestConstants.Users.USER2_ID, email="*****@*****.**",
is_active=True, username="******", full_name="Jack"
),
TestConstants.Users.USER3_ID: UserDetails(
id=TestConstants.Users.USER3_ID, email="*****@*****.**",
is_active=True, username="******", full_name="Jill"
),
}
WORKGROUP = WorkgroupDetails(**{
"id": TestConstants.Groups.GROUP1_ID,
"name": "Group 1",
"project": 1,
"groups": [],
"users": [
{"id": user.id, "username": user.username, "email": user.email}
for user in KNOWN_USERS.values()
],
"submissions": [],
"workgroup_reviews": [],
"peer_reviews": []
})
OTHER_GROUPS = {
TestConstants.Groups.GROUP2_ID: WorkgroupDetails(id=TestConstants.Groups.GROUP2_ID, name="Group 2"),
TestConstants.Groups.GROUP3_ID: WorkgroupDetails(id=TestConstants.Groups.GROUP3_ID, name="Group 3"),
}
def make_submission_data(doc_url, doc_filename, upload_date, user_details):
return {
def test_ta_grading(self):
self.__prepare_scenario_for_ta_graded_activity()
user_id, group_id = 22, 3
self.project_api_mock.get_user_preferences = mock.Mock(
return_value={UserAwareXBlockMixin.TA_REVIEW_KEY: group_id})
self.project_api_mock.get_user_roles_for_course = mock.Mock(
return_value=set(AuthXBlockMixin.DEFAULT_TA_ROLE))
self.project_api_mock.get_workgroup_by_id.side_effect = lambda g_id: WorkgroupDetails(
id=g_id, users=[{
"id": 1
}])
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self.assertTrue(stage_element.has_admin_grading_notification)
self.project_api_mock.get_workgroup_by_id.assert_called_with(group_id)
self.assertEqual(len(stage_element.groups), 1)
group = stage_element.groups[0]
self.assertEqual(group.subject_id, str(group_id))
self.select_review_subject(group)
submissions = {
"group_score": "100",
"group_q1": "Y",
"group_q2": "Awesome"
}
questions = stage_element.form.questions
questions[0].control.select_option(submissions["group_score"])
questions[1].control.select_option(submissions["group_q1"])
questions[2].control.fill_text(submissions["group_q2"])
self.assertTrue(stage_element.form.submit.is_displayed())
self.assertEqual(stage_element.form.submit.text,
"Submit") # first time here - should read Submit
# mocking response after submitting
self.project_api_mock.get_workgroup_review_items_for_group.return_value = [
{
"reviewer": str(user_id),
"answer": answer,
'question': question,
"workgroup": stage_element.form.group_id
} for question, answer in submissions.iteritems()
]
with mock.patch.object(WorkbenchRuntime, 'publish') as patched_method:
self.click_submit(stage_element)
self.assertTrue(patched_method.called)
publish_args, publish_kwargs = patched_method.call_args
self.assertEqual(publish_kwargs, {})
self.assertIsInstance(publish_args[0], PeerReviewStage)
self.assertEqual(publish_args[0].id, stage_element.id)
self.assertEqual(publish_args[1], 'progress')
self.assertEqual(publish_args[2], {'user_id': user_id})
self.project_api_mock.submit_workgroup_review_items.assert_called_with(
str(user_id), stage_element.form.group_id, self.activity_id,
submissions)
def _make_workgroup(user_ids):
return WorkgroupDetails(users=[{'id': user_id} for user_id in user_ids])
