def test_completion(self):
user_id = 1
other_users = set(KNOWN_USERS.keys()) - {user_id}
expected_submissions = {
"peer_score": "10",
"peer_q1": "Y",
"peer_q2": "Awesome"
}
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self.project_api_mock.get_peer_review_items_for_group.return_value = [
{
"question": question,
"answer": answer,
"workgroup": 1,
"user": peer_id,
"reviewer": str(user_id),
"content_id": self.activity_id,
} for question, answer in expected_submissions.iteritems()
for peer_id in other_users
]
peer = stage_element.peers[0]
self.select_review_subject(peer)
questions = stage_element.form.questions
self.wait_for_ajax()
questions[0].control.select_option(expected_submissions["peer_score"])
questions[1].control.select_option(expected_submissions["peer_q1"])
questions[2].control.fill_text(expected_submissions["peer_q2"])
self.submit_and_assert_completion_published(stage_element, user_id)
def test_completion(self):
user_id = 1
workgroups_to_review = OTHER_GROUPS.keys()
expected_submissions = {
"group_score": "100",
"group_q1": "Y",
"group_q2": "200"
}
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self.project_api_mock.get_workgroup_review_items_for_group.return_value = [
{
"question": question,
"answer": answer,
"workgroup": group_id,
"reviewer": str(reviewer_id),
"content_id": self.activity_id,
} for question, answer in expected_submissions.iteritems()
for group_id in workgroups_to_review
for reviewer_id in KNOWN_USERS.keys()
]
group = stage_element.groups[0]
self.select_review_subject(group)
questions = stage_element.form.questions
questions[0].control.select_option(expected_submissions["group_score"])
questions[1].control.select_option(expected_submissions["group_q1"])
questions[2].control.fill_text(expected_submissions["group_q2"])
self.submit_and_assert_completion_published(stage_element, user_id)
def test_completion(self):
user_id = 1
workgroups_to_review = OTHER_GROUPS.keys()
expected_submissions = {
"group_score": "100",
"group_q1": "Y",
"group_q2": "200"
}
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self.project_api_mock.get_workgroup_review_items_for_group.return_value = [
{
"question": question,
"answer": answer,
"workgroup": group_id,
"reviewer": str(reviewer_id),
"content_id": self.activity_id,
}
for question, answer in expected_submissions.iteritems()
for group_id in workgroups_to_review
for reviewer_id in KNOWN_USERS.keys()
]
group = stage_element.groups[0]
self.select_review_subject(group)
questions = stage_element.form.questions
questions[0].control.select_option(expected_submissions["group_score"])
questions[1].control.select_option(expected_submissions["group_q1"])
questions[2].control.fill_text(expected_submissions["group_q2"])
self.submit_and_assert_completion_published(stage_element, user_id)
def test_completion(self):
user_id = 1
other_users = set(KNOWN_USERS.keys()) - {user_id}
expected_submissions = {
"peer_score": "10",
"peer_q1": "Y",
"peer_q2": "Awesome"
}
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self.project_api_mock.get_peer_review_items_for_group.return_value = [
{
"question": question,
"answer": answer,
"workgroup": 1,
"user": peer_id,
"reviewer": str(user_id),
"content_id": self.activity_id,
}
for question, answer in expected_submissions.iteritems()
for peer_id in other_users
]
peer = stage_element.peers[0]
self.select_review_subject(peer)
questions = stage_element.form.questions
self.wait_for_ajax()
questions[0].control.select_option(expected_submissions["peer_score"])
questions[1].control.select_option(expected_submissions["peer_q1"])
questions[2].control.fill_text(expected_submissions["peer_q2"])
self.submit_and_assert_completion_published(stage_element, user_id)
def test_submission(self, user_id):
self.make_patch(TeamEvaluationStage, 'anonymous_student_id',
str(user_id))
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self._setup_review_items_store()
initial_statuses = {
usr_id: ReviewState.NOT_STARTED
for usr_id in list(KNOWN_USERS.keys()) if usr_id != user_id
}
self._assert_teammate_statuses(stage_element,
initial_statuses) # precondition check
peer = stage_element.peers[0]
self.select_review_subject(peer)
expected_submissions = {
"peer_score": "10",
"peer_q1": "Y",
"peer_q2": "Awesome"
}
questions = stage_element.form.questions
questions[0].control.select_option(expected_submissions["peer_score"])
questions[1].control.select_option(expected_submissions["peer_q1"])
questions[2].control.fill_text(expected_submissions["peer_q2"])
self.assertTrue(stage_element.form.submit.is_displayed())
self.assertEqual(stage_element.form.submit.text,
"Submit") # first time here - should read Submit
self.click_submit(stage_element)
self.project_api_mock.submit_peer_review_items.assert_called_once_with(
str(user_id), stage_element.form.peer_id, 1, self.activity_id,
expected_submissions)
expected_statuses = {
usr_id: ReviewState.NOT_STARTED
for usr_id in KNOWN_USERS.keys() if usr_id != user_id
}
expected_statuses[int(
peer.subject_id
)] = ReviewState.COMPLETED # status is refreshed after submission
self._assert_teammate_statuses(stage_element, expected_statuses)
def test_interaction(self, user_id):
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
other_users = set(KNOWN_USERS.keys()) - {user_id}
# A default selection should be made automatically.
self.assertEquals(stage_element.form.peer_id, min(other_users))
peers = stage_element.peers
self.assertEqual(len(peers), len(other_users))
for user_id, peer in zip(other_users, peers):
self.assertEqual(peer.name, KNOWN_USERS[user_id].username)
self.select_review_subject(peer)
self.assertEqual(stage_element.form.peer_id, user_id)
def test_interaction(self, user_id):
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
other_users = set(KNOWN_USERS.keys()) - {user_id}
# A default selection should be made automatically.
self.assertEquals(stage_element.form.peer_id, min(other_users))
peers = stage_element.peers
self.assertEqual(len(peers), len(other_users))
for user_id, peer in zip(other_users, peers):
self.assertEqual(peer.name, KNOWN_USERS[user_id].username)
self.select_review_subject(peer)
self.assertEqual(stage_element.form.peer_id, user_id)
def test_submission(self, user_id):
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self._setup_review_items_store()
initial_statuses = {usr_id: ReviewState.NOT_STARTED for usr_id in KNOWN_USERS.keys() if usr_id != user_id}
self._assert_teammate_statuses(stage_element, initial_statuses) # precondition check
peer = stage_element.peers[0]
self.select_review_subject(peer)
expected_submissions = {
"peer_score": "10",
"peer_q1": "Y",
"peer_q2": "Awesome"
}
questions = stage_element.form.questions
questions[0].control.select_option(expected_submissions["peer_score"])
questions[1].control.select_option(expected_submissions["peer_q1"])
questions[2].control.fill_text(expected_submissions["peer_q2"])
self.assertTrue(stage_element.form.submit.is_displayed())
self.assertEqual(stage_element.form.submit.text, "Submit") # first time here - should read Submit
self.click_submit(stage_element)
self.project_api_mock.submit_peer_review_items.assert_called_once_with(
str(user_id),
stage_element.form.peer_id,
1,
self.activity_id,
expected_submissions
)
expected_statuses = {usr_id: ReviewState.NOT_STARTED for usr_id in KNOWN_USERS.keys() if usr_id != user_id}
expected_statuses[int(peer.subject_id)] = ReviewState.COMPLETED # status is refreshed after submission
self._assert_teammate_statuses(stage_element, expected_statuses)
class TeamEvaluationStageTest(BaseReviewStageTest):
stage_type = TeamEvaluationStage
stage_element = ReviewStageElement
STAGE_DATA_XML = textwrap.dedent("""
<gp-v2-peer-selector/>
<gp-v2-review-question question_id="peer_score" title="How about that?" required="true" single_line="true">
<opt:question_content>
<![CDATA[
<select>
<option value="">Rating</option>
<option value="1">1</option>
<option value="2">2</option>
<option value="3">3</option>
<option value="4">4</option>
<option value="5">5</option>
<option value="6">6</option>
<option value="7">7</option>
<option value="8">8</option>
<option value="9">9</option>
<option value="10">10</option>
</select>
]]>
</opt:question_content>
</gp-v2-review-question>
<gp-v2-review-question question_id="peer_q1" title="Were they helpful?" required="true" single_line="true">
<opt:question_content>
<![CDATA[
<select>
<option value="Y">Yes</option>
<option value="N">No</option>
</select>
]]>
</opt:question_content>
</gp-v2-review-question>
<gp-v2-review-question question_id="peer_q2" title="General Comments" required="false">
<opt:question_content>
<![CDATA[
<textarea/>
]]>
</opt:question_content>
</gp-v2-review-question>
""")
REQUIRED_QUESTION_ID1 = "peer_score"
REQUIRED_QUESTION_ID2 = "peer_q1"
def setUp(self):
super(TeamEvaluationStageTest, self).setUp()
self.project_api_mock.get_peer_review_items = mock.Mock(
return_value={})
self.load_scenario_xml(self.build_scenario_xml(self.STAGE_DATA_XML),
load_immediately=False)
def _setup_review_items_store(self, initial_items=None):
store = defaultdict(list)
if initial_items:
store.update(initial_items)
def get_review_items(_reviewer_id, peer_id, _group_id, _content_id):
return store.get(peer_id, [])
def submit_peer_review_items(reviewer_id, peer_id, group_id,
content_id, data):
new_items = [
mri(reviewer_id,
question_id,
peer=peer_id,
content_id=content_id,
answer=answer,
group=group_id)
for question_id, answer in data.iteritems() if len(answer) > 0
]
store[peer_id].extend(new_items)
self.project_api_mock.get_peer_review_items = mock.Mock(
side_effect=get_review_items)
self.project_api_mock.submit_peer_review_items = mock.Mock(
side_effect=submit_peer_review_items)
def _assert_teammate_statuses(self, stage_element, expected_statuses):
teammate_statuses = {
int(peer.subject_id): peer.review_status
for peer in stage_element.peers
}
self.assertEqual(teammate_statuses, expected_statuses)
def test_rendering_questions(self):
stage_element = self.get_stage(self.go_to_view())
expected_options = {str(idx): str(idx) for idx in xrange(1, 11)}
expected_options.update({"": "Rating"})
questions = stage_element.form.questions
self.assertEqual(questions[0].label, "How about that?")
self.assertEqual(questions[0].control.name, "peer_score")
self.assertEqual(questions[0].control.tag_name, "select")
self.assertEqual(questions[0].control.options, expected_options)
self.assertEqual(questions[1].label, "Were they helpful?")
self.assertEqual(questions[1].control.name, "peer_q1")
self.assertEqual(questions[1].control.tag_name, "select")
self.assertEqual(questions[1].control.options, {"Y": "Yes", "N": "No"})
self.assertEqual(questions[2].label, "General Comments")
self.assertEqual(questions[2].control.name, "peer_q2")
self.assertEqual(questions[2].control.tag_name, "textarea")
def test_teammate_review_statuses(self):
user_id = TestConstants.Users.USER1_ID
reviews = {
TestConstants.Users.USER2_ID: [
mri(user_id,
self.REQUIRED_QUESTION_ID1,
peer=TestConstants.Users.USER2_ID,
answer='not empty'),
],
TestConstants.Users.USER3_ID: [
mri(user_id,
self.REQUIRED_QUESTION_ID1,
peer=TestConstants.Users.USER3_ID,
answer='not empty'),
mri(user_id,
self.REQUIRED_QUESTION_ID2,
peer=TestConstants.Users.USER3_ID,
answer='other')
],
}
self._setup_review_items_store(reviews)
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
expected_statuses = {
TestConstants.Users.USER2_ID: ReviewState.INCOMPLETE,
TestConstants.Users.USER3_ID: ReviewState.COMPLETED
}
self._assert_teammate_statuses(stage_element, expected_statuses)
@ddt.data(*KNOWN_USERS.keys()) # pylint: disable=star-args
def test_interaction(self, user_id):
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
other_users = set(KNOWN_USERS.keys()) - {user_id}
# A default selection should be made automatically.
self.assertEquals(stage_element.form.peer_id, min(other_users))
peers = stage_element.peers
self.assertEqual(len(peers), len(other_users))
for user_id, peer in zip(other_users, peers):
self.assertEqual(peer.name, KNOWN_USERS[user_id].username)
self.select_review_subject(peer)
self.assertEqual(stage_element.form.peer_id, user_id)
@ddt.data(*KNOWN_USERS.keys()) # pylint: disable=star-args
def test_submission(self, user_id):
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self._setup_review_items_store()
initial_statuses = {
usr_id: ReviewState.NOT_STARTED
for usr_id in KNOWN_USERS.keys() if usr_id != user_id
}
self._assert_teammate_statuses(stage_element,
initial_statuses) # precondition check
peer = stage_element.peers[0]
self.select_review_subject(peer)
expected_submissions = {
"peer_score": "10",
"peer_q1": "Y",
"peer_q2": "Awesome"
}
questions = stage_element.form.questions
questions[0].control.select_option(expected_submissions["peer_score"])
questions[1].control.select_option(expected_submissions["peer_q1"])
questions[2].control.fill_text(expected_submissions["peer_q2"])
self.assertTrue(stage_element.form.submit.is_displayed())
self.assertEqual(stage_element.form.submit.text,
"Submit") # first time here - should read Submit
self.click_submit(stage_element)
self.project_api_mock.submit_peer_review_items.assert_called_once_with(
str(user_id), stage_element.form.peer_id, 1, self.activity_id,
expected_submissions)
expected_statuses = {
usr_id: ReviewState.NOT_STARTED
for usr_id in KNOWN_USERS.keys() if usr_id != user_id
}
expected_statuses[int(
peer.subject_id
)] = ReviewState.COMPLETED # status is refreshed after submission
self._assert_teammate_statuses(stage_element, expected_statuses)
def test_persistence_and_resubmission(self):
user_id = 1
expected_submissions = {
"peer_score": "10",
"peer_q1": "Y",
"peer_q2": "Awesome"
}
self.project_api_mock.get_peer_review_items.return_value = [{
"question":
question,
"answer":
answer,
"user":
TestConstants.Users.USER2_ID
} for question, answer in expected_submissions.iteritems()]
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
peer = stage_element.peers[0]
self.select_review_subject(peer)
# loading peer review items from project_api
self.project_api_mock.get_peer_review_items.assert_called_with(
str(user_id),
stage_element.form.peer_id,
1,
self.activity_id,
)
questions = stage_element.form.questions
self.assertEqual(questions[0].control.value,
expected_submissions["peer_score"])
self.assertEqual(questions[1].control.value,
expected_submissions["peer_q1"])
self.assertEqual(questions[2].control.value,
expected_submissions["peer_q2"])
new_submissions = {
"peer_score": "2",
"peer_q1": "N",
"peer_q2": "Awful"
}
questions[0].control.select_option(new_submissions["peer_score"])
questions[1].control.select_option(new_submissions["peer_q1"])
questions[2].control.fill_text(new_submissions["peer_q2"])
self.assertEqual(stage_element.form.submit.text, "Resubmit")
self.click_submit(stage_element)
self.project_api_mock.submit_peer_review_items.assert_called_once_with(
str(user_id), stage_element.form.peer_id, 1, self.activity_id,
new_submissions)
def test_completion(self):
user_id = 1
other_users = set(KNOWN_USERS.keys()) - {user_id}
expected_submissions = {
"peer_score": "10",
"peer_q1": "Y",
"peer_q2": "Awesome"
}
stage_element = self.get_stage(self.go_to_view(student_id=user_id))
self.project_api_mock.get_peer_review_items_for_group.return_value = [
{
"question": question,
"answer": answer,
"workgroup": 1,
"user": peer_id,
"reviewer": str(user_id),
"content_id": self.activity_id,
} for question, answer in expected_submissions.iteritems()
for peer_id in other_users
]
peer = stage_element.peers[0]
self.select_review_subject(peer)
questions = stage_element.form.questions
self.wait_for_ajax()
questions[0].control.select_option(expected_submissions["peer_score"])
questions[1].control.select_option(expected_submissions["peer_q1"])
questions[2].control.fill_text(expected_submissions["peer_q2"])
self.submit_and_assert_completion_published(stage_element, user_id)
