def test_users_completion_multiple_groups(self, target_users, questions, review_items, expected_result):
workgroups = [
mk_wg(GROUP_ID, users=[{"id": 1}, {"id": 2}]),
mk_wg(OTHER_GROUP_ID, users=[{"id": 3}, {"id": 4}]),
]
self._set_project_api_responses(
{1: workgroups[0], 2: workgroups[0], 3: workgroups[1], 4: workgroups[1]},
{
group_id: [self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.iteritems()
}
)
self.assert_users_completion(expected_result, questions, target_users)
# checks if caching is ok
expected_calls = [
mock.call(GROUP_ID, self.block.activity_content_id),
mock.call(OTHER_GROUP_ID, self.block.activity_content_id)
]
self.assertEqual(self.project_api_mock.get_peer_review_items_for_group.mock_calls, expected_calls)
def test_users_completion_multiple_groups(self, target_users, questions, review_items, expected_result):
workgroups = [
mk_wg(GROUP_ID, users=[{"id": 1}, {"id": 2}]),
mk_wg(OTHER_GROUP_ID, users=[{"id": 3}, {"id": 4}]),
]
self._set_project_api_responses(
{1: workgroups[0], 2: workgroups[0], 3: workgroups[1], 4: workgroups[1]},
{
group_id: [self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.items()
}
)
self.assert_users_completion(expected_result, questions, target_users)
# checks if caching is ok
expected_calls = [
mock.call(GROUP_ID, self.block.activity_content_id),
mock.call(OTHER_GROUP_ID, self.block.activity_content_id)
]
self.assertEqual(self.project_api_mock.get_peer_review_items_for_group.mock_calls, expected_calls)
def test_get_external_group_status(self, reviewers, questions, review_items, expected_result):
group = mk_wg(GROUP_ID, [{"id": 1}])
self.project_api_mock.get_workgroup_reviewers.return_value = [{'id': user_id} for user_id in reviewers]
self._set_project_api_responses(
group,
{
group.id: [self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.iteritems()
}
)
self.assert_group_completion(group, questions, expected_result)
self.project_api_mock.get_workgroup_reviewers.assert_called_once_with(group.id, self.block.activity_content_id)
def test_users_completion_same_groups(self, groups_to_review, questions, review_items, expected_result):
target_users = [1, 2]
review_items = [self._parse_review_item_string(review_item_str) for review_item_str in review_items]
self._set_project_api_responses(
{user_id: [mk_wg(group_id) for group_id in groups_to_review] for user_id in target_users},
{GROUP_ID: review_items}
)
self.assert_users_completion(expected_result, questions, target_users)
# checks if caching is ok
self.project_api_mock.get_workgroup_review_items_for_group.assert_called_once_with(
GROUP_ID, self.block.activity_content_id
)
def test_users_completion_single_user(self, groups_to_review, questions, review_items, expected_result):
user_id = 1
review_items = [self._parse_review_item_string(review_item_str) for review_item_str in review_items]
self._set_project_api_responses(
{user_id: [mk_wg(group_id) for group_id in groups_to_review]},
{GROUP_ID: review_items}
)
self.assert_users_completion(expected_result, questions, [user_id])
# checks if caching is ok
expected_calls = [mock.call(group_id, self.block.activity_content_id) for group_id in groups_to_review]
self.assertEqual(self.project_api_mock.get_workgroup_review_items_for_group.mock_calls, expected_calls)
def test_users_completion_same_group_users(self, users_in_group, questions, review_items, expected_result):
workgroup_id = 1
workgroup_data = mk_wg(workgroup_id, users=[{"id": uid} for uid in users_in_group])
review_items = [self._parse_review_item_string(review_item_str) for review_item_str in review_items]
self._set_project_api_responses(
{uid: workgroup_data for uid in users_in_group},
{workgroup_id: review_items}
)
self.assert_users_completion(expected_result, questions, users_in_group)
# checks if caching is ok
self.project_api_mock.get_peer_review_items_for_group.assert_called_once_with(
workgroup_id, self.block.activity_content_id
)
def test_users_completion_same_group_users(self, users_in_group, questions, review_items, expected_result):
workgroup_id = 1
workgroup_data = mk_wg(workgroup_id, users=[{"id": uid} for uid in users_in_group])
review_items = [self._parse_review_item_string(review_item_str) for review_item_str in review_items]
self._set_project_api_responses(
{uid: workgroup_data for uid in users_in_group},
{workgroup_id: review_items}
)
self.assert_users_completion(expected_result, questions, users_in_group)
# checks if caching is ok
self.project_api_mock.get_peer_review_items_for_group.assert_called_once_with(
workgroup_id, self.block.activity_content_id
)
def test_ta_get_external_group_status(self, ta_reviewers, questions, review_items, expected_result):
group_to_review = mk_wg(GROUP_ID, [{"id": 1}])
self.activity_mock.is_ta_graded = True
self._set_project_api_responses(
group_to_review,
{
group_to_review.id: [self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.iteritems()
}
)
with patch_obj(self.block, 'is_user_ta') as patched_outsider_allowed:
patched_outsider_allowed.side_effect = lambda user_id, _course_id: user_id in ta_reviewers
self.assert_group_completion(group_to_review, questions, expected_result)
def test_ta_get_external_group_status(self, ta_reviewers, questions,
review_items, expected_result):
group_to_review = mk_wg(GROUP_ID, [{"id": 1}])
self.activity_mock.is_ta_graded = True
self._set_project_api_responses(
group_to_review, {
group_to_review.id:
[self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.iteritems()
})
with patch_obj(self.block, 'is_user_ta') as patched_outsider_allowed:
patched_outsider_allowed.side_effect = lambda user_id, _course_id: user_id in ta_reviewers
self.assert_group_completion(group_to_review, questions,
expected_result)
def test_get_external_group_status(self, reviewers, questions,
review_items, expected_result):
group = mk_wg(GROUP_ID, [{"id": 1}])
self.project_api_mock.get_workgroup_reviewers.return_value = [{
'id':
user_id
} for user_id in reviewers]
self._set_project_api_responses(
group, {
group.id:
[self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.iteritems()
})
self.assert_group_completion(group, questions, expected_result)
self.project_api_mock.get_workgroup_reviewers.assert_called_once_with(
group.id, self.block.activity_content_id)
def test_users_completion_same_groups(self, groups_to_review, questions,
review_items, expected_result):
target_users = [1, 2]
review_items = [
self._parse_review_item_string(review_item_str)
for review_item_str in review_items
]
self._set_project_api_responses(
{
user_id: [mk_wg(group_id) for group_id in groups_to_review]
for user_id in target_users
}, {GROUP_ID: review_items})
self.assert_users_completion(expected_result, questions, target_users)
# checks if caching is ok
self.project_api_mock.get_workgroup_review_items_for_group.assert_called_once_with(
GROUP_ID, self.block.activity_content_id)
def test_users_completion_multiple_groups(
self, target_users, group_reviewers, questions, review_items, expected_result
):
groups_to_review = defaultdict(list)
for group_id, reviewers in group_reviewers.iteritems():
for reviewer in reviewers:
groups_to_review[reviewer].append(mk_wg(group_id))
self._set_project_api_responses(
groups_to_review,
{
group_id: [self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.iteritems()
}
)
self.assert_users_completion(expected_result, questions, target_users)
# checks if caching is ok
expected_calls = [
mock.call(group_id, self.block.activity_content_id) for group_id in group_reviewers.keys()
]
self.assertEqual(self.project_api_mock.get_workgroup_review_items_for_group.mock_calls, expected_calls)
def test_users_completion_single_user(self, groups_to_review, questions,
review_items, expected_result):
user_id = 1
review_items = [
self._parse_review_item_string(review_item_str)
for review_item_str in review_items
]
self._set_project_api_responses(
{user_id: [mk_wg(group_id) for group_id in groups_to_review]},
{GROUP_ID: review_items})
self.assert_users_completion(expected_result, questions, [user_id])
# checks if caching is ok
expected_calls = [
mock.call(group_id, self.block.activity_content_id)
for group_id in groups_to_review
]
self.assertEqual(
self.project_api_mock.get_workgroup_review_items_for_group.
mock_calls, expected_calls)
def test_users_completion_multiple_groups(self, target_users,
group_reviewers, questions,
review_items, expected_result):
groups_to_review = defaultdict(list)
for group_id, reviewers in group_reviewers.iteritems():
for reviewer in reviewers:
groups_to_review[reviewer].append(mk_wg(group_id))
self._set_project_api_responses(
groups_to_review, {
group_id:
[self._parse_review_item_string(item) for item in items]
for group_id, items in review_items.iteritems()
})
self.assert_users_completion(expected_result, questions, target_users)
# checks if caching is ok
expected_calls = [
mock.call(group_id, self.block.activity_content_id)
for group_id in group_reviewers.keys()
]
self.assertEqual(
self.project_api_mock.get_workgroup_review_items_for_group.
mock_calls, expected_calls)
class TestSubmissionStage(BaseStageTest):
block_to_test = SubmissionStage
def _set_upload_ids(self, upload_ids):
self.submissions_mock.return_value = [
mock.Mock(upload_id=upload_id) for upload_id in upload_ids
]
def setUp(self):
super(TestSubmissionStage, self).setUp()
self.submissions_mock = mock.PropertyMock()
self.make_patch(self.block_to_test, 'submissions',
self.submissions_mock)
def test_stage_is_not_graded(self):
self.assertFalse(self.block.is_graded_stage)
def test_stage_is_shown_on_detail_dashboard(self):
self.assertTrue(self.block.shown_on_detail_view)
@ddt.data(
# no submissions at all - not started
(['u1'], [mk_wg(1, [{
'id': 1
}])], {}, (set(), set())),
# all submissions for one group with one user - user completed the stage
(['u1'], [mk_wg(1, [{
'id': 1
}])], {
1: ['u1']
}, ({1}, set())),
# all submissionss for one group with two users - both users completed the stage
(['u1'], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}])], {
1: ['u1']
}, ({1, 2}, set())),
# some submissions for one group with one user - user partially completed the stage
(['u1', 'u2'], [mk_wg(1, [{
'id': 1
}])], {
1: ['u1']
}, (set(), {1})),
# some submissions for one group with two users - both users partially completed the stage
(['u1', 'u2'], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}])], {
1: ['u1']
}, (set(), {1, 2})),
# two groups, some submissions for g1 - users in g1 partially completed, users in g2 not started
(['u1', 'u2'
], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}]), mk_wg(2, [{
'id': 3
}])], {
1: ['u1']
}, (set(), {1, 2})),
# two groups, some submissions for g1 and g2 - users both in g1 and g2 partially completed
(['u1', 'u2'
], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}]), mk_wg(2, [{
'id': 3
}])], {
1: ['u1'],
2: ['u2']
}, (set(), {1, 2, 3})),
# two groups, all submissions for g1, some for g2 - g1 users completed, g2 users partially completed
(['u1', 'u2'
], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}]), mk_wg(2, [{
'id': 3
}])], {
1: ['u1', 'u2'],
2: ['u2']
}, ({1, 2}, {3})),
# two groups, some submissions for g1, all for g2 - g2 users completed, g1 users partially completed
(['u1', 'u2'
], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}]), mk_wg(2, [{
'id': 3
}])], {
1: ['u1'],
2: ['u1', 'u2']
}, ({3}, {1, 2})),
# two groups, all submissions for g2, none for g1 - g2 users completed, g1 users not started
(['u1', 'u2'
], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}]), mk_wg(2, [{
'id': 3
}])], {
2: ['u1', 'u2']
}, ({3}, set())),
# two groups, all submissions for g1 and g2 - users in g1 and g2 completed
(['u1', 'u2'
], [mk_wg(1, [{
'id': 1
}, {
'id': 2
}]), mk_wg(2, [{
'id': 3
}])], {
1: ['u1', 'u2'],
2: ['u1', 'u2']
}, ({1, 2, 3}, set())),
)
@ddt.unpack
def test_get_users_completion(self, uploads, workgroups, submissions,
expected_result):
workgroup_submissions = {
group_id:
{upload_id: 'irrelevant'
for upload_id in uploaded_submissions}
for group_id, uploaded_submissions in submissions.items()
}
expected_completed, expected_partially_completed = expected_result
expected_calls = [mock.call(group.id) for group in workgroups]
def get_submissions_by_id(group_id):
return workgroup_submissions.get(group_id, {})
self._set_upload_ids(uploads)
self.project_api_mock.get_latest_workgroup_submissions_by_id.side_effect = get_submissions_by_id
completed, partially_completed = self.block.get_users_completion(
workgroups, 'irrelevant')
self.assertEqual(completed, expected_completed)
self.assertEqual(partially_completed, expected_partially_completed)
self.assertEqual(
self.project_api_mock.get_latest_workgroup_submissions_by_id.
mock_calls, expected_calls)
