Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-12-08T01:08:32Z

Yyang53:

=Introduction=
Expertiza supports multi-round peer reviews. Currently, in this situation, student who did not do the previous round peer reviews can still do the subsequent round peer reviews, but will lose about 50 points according to the deduction policy. Therefore, it will be fairer to provide instructor an option to decide whether a student can do the subsequent round peer reviews when s/he did not do the previous round peer reviews.

=Design Plan=
==UI Improvement==
In assignment#edit page “Review strategy” tab, add a checkbox (e.g., “Allow student to join reviews late”*) to allow instructor to decide whether students can do the second round peer reviews without the first round peer reviews; by default this box is unchecked and it only appears when there are multi-round peer reviews.
*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
==Functionality Implementation==
===Explanation===
Currently, when students didn't request enough reviews(e.g. Each student is required to do at least 2 reviews, but s/he only request one in the first round), they can still request more reviews in the second round, but will lose points due to lack of first round reviews. Now, we want to add a functionality to split the case. Below is the flow chart that explains the improvement. * Note that whether submit or not doesn't matter, as long as request, it counts.

[[File:Diagram.png]]
===Code Level Design===
1. First, check whether a certain assignment is multi-rounds
Go to expertiza/app/models/assignment.rb, find the following function
<pre>
def number_of_current_round(topic_id)
next_due_date = DueDate.get_next_due_date(self.id, topic_id)
return 0 if next_due_date.nil?
next_due_date.round
#next_due_date.round ||= 0
end
</pre>
<pre>
def current_stage_name(topic_id = nil)
if self.staggered_deadline?
return (topic_id.nil? ? 'Unknown' : get_current_stage(topic_id))
end
due_date = find_current_stage(topic_id)
</pre>
check current rounds, if >=2, then checkbox can be clicked.

2. Then, Edit the database

Go to DB, add an attribute named 'is_second_round_allowed_checked' to assignment

3. Finally, add the function

Go to expertiza/app/models/assignment.rb, add a function called 'allow_second_round_review'. When rounds <2, do nothing; else, allow second_round reviews if box checked.

4. Change the view of student_review as following:
<pre>
<% if check_reviewable_topics(@assignment) or @assignment.get_current_stage(@topic_id) == "Finished" %>
<%= render :partial => 'responses', :locals => {:mappings => @review_mappings, :title => 'Review'} %>
<% if @assignment.number_of_current_round(@topic_id) == 1 or (@assignment.number_of_current_round(@topic_id) >= 2 and @assignment.allow_doing_subsequent_review_without_first_round) %>
<% if @assignment.dynamic_reviewer_assignment? %>
<% if @num_reviews_in_progress >= Assignment.max_outstanding_reviews %>
<br><br>
<span>Note: You can't have more than 2 outstanding reviews. You must complete one of your outstanding reviews before selecting another.</span>
<% elsif @assignment.num_reviews && @assignment.num_reviews >= 0 && @num_reviews_total >= @assignment.num_reviews%>
<br><br>
<span>Note: You can't do more than <%=@assignment.num_reviews%> reviews according to assignment policy.</span>
<%else %>
<%= render :partial => 'set_dynamic_review', :locals => {:assignment => @assignment, :participant => @participant} %>
<% end %>
<% end %>
<% end %>
<% else %>
</pre>
where the second if-statement ensures that the student can only have request option during first peer review round or get the permission from instructor during second or more round.

=Test Plan=
We plan to write a feature test for the project. Go to expertiza/spec/features folder, add a file named 'Allow_second_round_review'. Below is the details of our test.
==Test checkbox(Instructor side)==
1. Log in as instructor

2. Navigate to “Manage…”,then “Assignments”

3. Under “Actions”, choose “Edit”

4. Navigate to “Review Strategy”

5. See the checkbox “Allow student to join reviews late”
==Test task list(Student side)==
===Case 1: Check the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student cannot do the second review without the first one
===Case 2: Uncheck the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student can do the second review without the first one

=References=
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza in Github]

[[Expertiza documentation]]

[[Documentation on Database Tables]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-12-08T01:06:26Z

Yyang53: /* Code Level Design */

=Introduction=
Expertiza supports multi-round peer reviews. Currently, in this situation, student who did not do the previous round peer reviews can still do the subsequent round peer reviews, but will lose about 50 points according to the deduction policy. Therefore, it will be fairer to provide instructor an option to decide whether a student can do the subsequent round peer reviews when s/he did not do the previous round peer reviews.

=Design Plan=
==UI Improvement==
In assignment#edit page “Review strategy” tab, add a checkbox (e.g., “Allow student to join reviews late”*) to allow instructor to decide whether students can do the second round peer reviews without the first round peer reviews; by default this box is unchecked and it only appears when there are multi-round peer reviews.
*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
==Functionality Implementation==
===Explanation===
Currently, when students didn't request enough reviews(e.g. Each student is required to do at least 2 reviews, but s/he only request one in the first round), they can still request more reviews in the second round, but will lose points due to lack of first round reviews. Now, we want to add a functionality to split the case. Below is the flow chart that explains the improvement. * Note that whether submit or not doesn't matter, as long as request, it counts.

[[File:Diagram.png]]
===Code Level Design===
1. First, check whether a certain assignment is multi-rounds
Go to expertiza/app/models/assignment.rb, find the following function
<pre>
def number_of_current_round(topic_id)
next_due_date = DueDate.get_next_due_date(self.id, topic_id)
return 0 if next_due_date.nil?
next_due_date.round
#next_due_date.round ||= 0
end
</pre>
<pre>
def current_stage_name(topic_id = nil)
if self.staggered_deadline?
return (topic_id.nil? ? 'Unknown' : get_current_stage(topic_id))
end
due_date = find_current_stage(topic_id)
</pre>
check current rounds, if >=2, then checkbox can be clicked.

2. Then, Edit the database
Go to DB, add an attribute named 'is_second_round_allowed_checked' to assignment

3. Finally, add the function
Go to expertiza/app/models/assignment.rb, add a function called 'allow_second_round_review'. When rounds <2, do nothing; else, allow second_round reviews if box checked.

4. Change the view of student_review as following:
<pre>
<% if check_reviewable_topics(@assignment) or @assignment.get_current_stage(@topic_id) == "Finished" %>
<%= render :partial => 'responses', :locals => {:mappings => @review_mappings, :title => 'Review'} %>
<% if @assignment.number_of_current_round(@topic_id) == 1 or (@assignment.number_of_current_round(@topic_id) >= 2 and @assignment.allow_doing_subsequent_review_without_first_round) %>
<% if @assignment.dynamic_reviewer_assignment? %>
<% if @num_reviews_in_progress >= Assignment.max_outstanding_reviews %>
<br><br>
<span>Note: You can't have more than 2 outstanding reviews. You must complete one of your outstanding reviews before selecting another.</span>
<% elsif @assignment.num_reviews && @assignment.num_reviews >= 0 && @num_reviews_total >= @assignment.num_reviews%>
<br><br>
<span>Note: You can't do more than <%=@assignment.num_reviews%> reviews according to assignment policy.</span>
<%else %>
<%= render :partial => 'set_dynamic_review', :locals => {:assignment => @assignment, :participant => @participant} %>
<% end %>
<% end %>
<% end %>
<% else %>
</pre>
where the second if-statement ensures that the student can only have request option during first peer review round or get the permission from instructor during second or more round.

=Test Plan=
We plan to write a feature test for the project. Go to expertiza/spec/features folder, add a file named 'Allow_second_round_review'. Below is the details of our test.
==Test checkbox(Instructor side)==
1. Log in as instructor

2. Navigate to “Manage…”,then “Assignments”

3. Under “Actions”, choose “Edit”

4. Navigate to “Review Strategy”

5. See the checkbox “Allow student to join reviews late”
==Test task list(Student side)==
===Case 1: Check the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student cannot do the second review without the first one
===Case 2: Uncheck the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student can do the second review without the first one

=References=
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza in Github]

[[Expertiza documentation]]

[[Documentation on Database Tables]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-12-08T01:02:24Z

Yyang53: /* Code Level Design */

=Introduction=
Expertiza supports multi-round peer reviews. Currently, in this situation, student who did not do the previous round peer reviews can still do the subsequent round peer reviews, but will lose about 50 points according to the deduction policy. Therefore, it will be fairer to provide instructor an option to decide whether a student can do the subsequent round peer reviews when s/he did not do the previous round peer reviews.

=Design Plan=
==UI Improvement==
In assignment#edit page “Review strategy” tab, add a checkbox (e.g., “Allow student to join reviews late”*) to allow instructor to decide whether students can do the second round peer reviews without the first round peer reviews; by default this box is unchecked and it only appears when there are multi-round peer reviews.
*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
==Functionality Implementation==
===Explanation===
Currently, when students didn't request enough reviews(e.g. Each student is required to do at least 2 reviews, but s/he only request one in the first round), they can still request more reviews in the second round, but will lose points due to lack of first round reviews. Now, we want to add a functionality to split the case. Below is the flow chart that explains the improvement. * Note that whether submit or not doesn't matter, as long as request, it counts.

[[File:Diagram.png]]
===Code Level Design===
1. First, check whether a certain assignment is multi-rounds
Go to expertiza/app/models/assignment.rb, find the following function
<pre>
def number_of_current_round(topic_id)
next_due_date = DueDate.get_next_due_date(self.id, topic_id)
return 0 if next_due_date.nil?
next_due_date.round
#next_due_date.round ||= 0
end
</pre>
<pre>
def current_stage_name(topic_id = nil)
if self.staggered_deadline?
return (topic_id.nil? ? 'Unknown' : get_current_stage(topic_id))
end
due_date = find_current_stage(topic_id)
</pre>
check current rounds, if >=2, then checkbox can be clicked.
2. Then, Edit the database
Go to DB, add an attribute named 'is_second_round_allowed_checked' to assignment

3. Finally, add the function
Go to expertiza/app/models/assignment.rb, add a function called 'allow_second_round_review'. When rounds <2, do nothing; else, allow second_round reviews if box checked.

4. Change the view of student_review as following:
<pre>
<% if check_reviewable_topics(@assignment) or @assignment.get_current_stage(@topic_id) == "Finished" %>
<%= render :partial => 'responses', :locals => {:mappings => @review_mappings, :title => 'Review'} %>
<% if @assignment.number_of_current_round(@topic_id) == 1 or (@assignment.number_of_current_round(@topic_id) >= 2 and @assignment.allow_doing_subsequent_review_without_first_round) %>
<% if @assignment.dynamic_reviewer_assignment? %>
<% if @num_reviews_in_progress >= Assignment.max_outstanding_reviews %>
<br><br>
<span>Note: You can't have more than 2 outstanding reviews. You must complete one of your outstanding reviews before selecting another.</span>
<% elsif @assignment.num_reviews && @assignment.num_reviews >= 0 && @num_reviews_total >= @assignment.num_reviews%>
<br><br>
<span>Note: You can't do more than <%=@assignment.num_reviews%> reviews according to assignment policy.</span>
<%else %>
<%= render :partial => 'set_dynamic_review', :locals => {:assignment => @assignment, :participant => @participant} %>
<% end %>
<% end %>
<% end %>
<% else %>
</pre>
where the second if-statement ensures that the student can only have request option during first peer review round or get the permission from instructor during second or more round.

=Test Plan=
We plan to write a feature test for the project. Go to expertiza/spec/features folder, add a file named 'Allow_second_round_review'. Below is the details of our test.
==Test checkbox(Instructor side)==
1. Log in as instructor

2. Navigate to “Manage…”,then “Assignments”

3. Under “Actions”, choose “Edit”

4. Navigate to “Review Strategy”

5. See the checkbox “Allow student to join reviews late”
==Test task list(Student side)==
===Case 1: Check the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student cannot do the second review without the first one
===Case 2: Uncheck the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student can do the second review without the first one

=References=
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza in Github]

[[Expertiza documentation]]

[[Documentation on Database Tables]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-12-08T01:01:57Z

Yyang53: /* Code Level Design */

=Introduction=
Expertiza supports multi-round peer reviews. Currently, in this situation, student who did not do the previous round peer reviews can still do the subsequent round peer reviews, but will lose about 50 points according to the deduction policy. Therefore, it will be fairer to provide instructor an option to decide whether a student can do the subsequent round peer reviews when s/he did not do the previous round peer reviews.

=Design Plan=
==UI Improvement==
In assignment#edit page “Review strategy” tab, add a checkbox (e.g., “Allow student to join reviews late”*) to allow instructor to decide whether students can do the second round peer reviews without the first round peer reviews; by default this box is unchecked and it only appears when there are multi-round peer reviews.
*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
==Functionality Implementation==
===Explanation===
Currently, when students didn't request enough reviews(e.g. Each student is required to do at least 2 reviews, but s/he only request one in the first round), they can still request more reviews in the second round, but will lose points due to lack of first round reviews. Now, we want to add a functionality to split the case. Below is the flow chart that explains the improvement. * Note that whether submit or not doesn't matter, as long as request, it counts.

[[File:Diagram.png]]
===Code Level Design===
1. First, check whether a certain assignment is multi-rounds
Go to expertiza/app/models/assignment.rb, find the following function
<pre>
def number_of_current_round(topic_id)
next_due_date = DueDate.get_next_due_date(self.id, topic_id)
return 0 if next_due_date.nil?
next_due_date.round
#next_due_date.round ||= 0
end
</pre>
check rounds, if >=2, then checkbox can be clicked.
<pre>
def current_stage_name(topic_id = nil)
if self.staggered_deadline?
return (topic_id.nil? ? 'Unknown' : get_current_stage(topic_id))
end
due_date = find_current_stage(topic_id)
</pre>

2. Then, Edit the database
Go to DB, add an attribute named 'is_second_round_allowed_checked' to assignment

3. Finally, add the function
Go to expertiza/app/models/assignment.rb, add a function called 'allow_second_round_review'. When rounds <2, do nothing; else, allow second_round reviews if box checked.

4. Change the view of student_review as following:
<pre>
<% if check_reviewable_topics(@assignment) or @assignment.get_current_stage(@topic_id) == "Finished" %>
<%= render :partial => 'responses', :locals => {:mappings => @review_mappings, :title => 'Review'} %>
<% if @assignment.number_of_current_round(@topic_id) == 1 or (@assignment.number_of_current_round(@topic_id) >= 2 and @assignment.allow_doing_subsequent_review_without_first_round) %>
<% if @assignment.dynamic_reviewer_assignment? %>
<% if @num_reviews_in_progress >= Assignment.max_outstanding_reviews %>
<br><br>
<span>Note: You can't have more than 2 outstanding reviews. You must complete one of your outstanding reviews before selecting another.</span>
<% elsif @assignment.num_reviews && @assignment.num_reviews >= 0 && @num_reviews_total >= @assignment.num_reviews%>
<br><br>
<span>Note: You can't do more than <%=@assignment.num_reviews%> reviews according to assignment policy.</span>
<%else %>
<%= render :partial => 'set_dynamic_review', :locals => {:assignment => @assignment, :participant => @participant} %>
<% end %>
<% end %>
<% end %>
<% else %>
</pre>
where the second if-statement ensures that the student can only have request option during first peer review round or get the permission from instructor during second or more round.

=Test Plan=
We plan to write a feature test for the project. Go to expertiza/spec/features folder, add a file named 'Allow_second_round_review'. Below is the details of our test.
==Test checkbox(Instructor side)==
1. Log in as instructor

2. Navigate to “Manage…”,then “Assignments”

3. Under “Actions”, choose “Edit”

4. Navigate to “Review Strategy”

5. See the checkbox “Allow student to join reviews late”
==Test task list(Student side)==
===Case 1: Check the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student cannot do the second review without the first one
===Case 2: Uncheck the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student can do the second review without the first one

=References=
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza in Github]

[[Expertiza documentation]]

[[Documentation on Database Tables]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-12-08T01:00:50Z

Yyang53: /* Code Level Design */

=Introduction=
Expertiza supports multi-round peer reviews. Currently, in this situation, student who did not do the previous round peer reviews can still do the subsequent round peer reviews, but will lose about 50 points according to the deduction policy. Therefore, it will be fairer to provide instructor an option to decide whether a student can do the subsequent round peer reviews when s/he did not do the previous round peer reviews.

=Design Plan=
==UI Improvement==
In assignment#edit page “Review strategy” tab, add a checkbox (e.g., “Allow student to join reviews late”*) to allow instructor to decide whether students can do the second round peer reviews without the first round peer reviews; by default this box is unchecked and it only appears when there are multi-round peer reviews.
*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
==Functionality Implementation==
===Explanation===
Currently, when students didn't request enough reviews(e.g. Each student is required to do at least 2 reviews, but s/he only request one in the first round), they can still request more reviews in the second round, but will lose points due to lack of first round reviews. Now, we want to add a functionality to split the case. Below is the flow chart that explains the improvement. * Note that whether submit or not doesn't matter, as long as request, it counts.

[[File:Diagram.png]]
===Code Level Design===
1. First, check whether a certain assignment is multi-rounds
Go to expertiza/app/models/assignment.rb, find the following function
<pre>
def current_stage_name(topic_id = nil)
if self.staggered_deadline?
return (topic_id.nil? ? 'Unknown' : get_current_stage(topic_id))
end
due_date = find_current_stage(topic_id)
</pre>
check rounds, if >=2, then checkbox can be clicked.

2. Then, Edit the database
Go to DB, add an attribute named 'is_second_round_allowed_checked' to assignment

3. Finally, add the function
Go to expertiza/app/models/assignment.rb, add a function called 'allow_second_round_review'. When rounds <2, do nothing; else, allow second_round reviews if box checked.

4. Change the view of student_review as following:
<pre>
<% if check_reviewable_topics(@assignment) or @assignment.get_current_stage(@topic_id) == "Finished" %>
<%= render :partial => 'responses', :locals => {:mappings => @review_mappings, :title => 'Review'} %>
<% if @assignment.number_of_current_round(@topic_id) == 1 or (@assignment.number_of_current_round(@topic_id) >= 2 and @assignment.allow_doing_subsequent_review_without_first_round) %>
<% if @assignment.dynamic_reviewer_assignment? %>
<% if @num_reviews_in_progress >= Assignment.max_outstanding_reviews %>
<br><br>
<span>Note: You can't have more than 2 outstanding reviews. You must complete one of your outstanding reviews before selecting another.</span>
<% elsif @assignment.num_reviews && @assignment.num_reviews >= 0 && @num_reviews_total >= @assignment.num_reviews%>
<br><br>
<span>Note: You can't do more than <%=@assignment.num_reviews%> reviews according to assignment policy.</span>
<%else %>
<%= render :partial => 'set_dynamic_review', :locals => {:assignment => @assignment, :participant => @participant} %>
<% end %>
<% end %>
<% end %>
<% else %>
</pre>
where the second if-statement ensures that the student can only have request option during first peer review round or get the permission from instructor during second or more round.

=Test Plan=
We plan to write a feature test for the project. Go to expertiza/spec/features folder, add a file named 'Allow_second_round_review'. Below is the details of our test.
==Test checkbox(Instructor side)==
1. Log in as instructor

2. Navigate to “Manage…”,then “Assignments”

3. Under “Actions”, choose “Edit”

4. Navigate to “Review Strategy”

5. See the checkbox “Allow student to join reviews late”
==Test task list(Student side)==
===Case 1: Check the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student cannot do the second review without the first one
===Case 2: Uncheck the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student can do the second review without the first one

=References=
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza in Github]

[[Expertiza documentation]]

[[Documentation on Database Tables]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-12-08T00:53:26Z

Yyang53: /* Code Level Design */

=Introduction=
Expertiza supports multi-round peer reviews. Currently, in this situation, student who did not do the previous round peer reviews can still do the subsequent round peer reviews, but will lose about 50 points according to the deduction policy. Therefore, it will be fairer to provide instructor an option to decide whether a student can do the subsequent round peer reviews when s/he did not do the previous round peer reviews.

=Design Plan=
==UI Improvement==
In assignment#edit page “Review strategy” tab, add a checkbox (e.g., “Allow student to join reviews late”*) to allow instructor to decide whether students can do the second round peer reviews without the first round peer reviews; by default this box is unchecked and it only appears when there are multi-round peer reviews.
*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
==Functionality Implementation==
===Explanation===
Currently, when students didn't request enough reviews(e.g. Each student is required to do at least 2 reviews, but s/he only request one in the first round), they can still request more reviews in the second round, but will lose points due to lack of first round reviews. Now, we want to add a functionality to split the case. Below is the flow chart that explains the improvement. * Note that whether submit or not doesn't matter, as long as request, it counts.

[[File:Diagram.png]]
===Code Level Design===
1. First, check whether a certain assignment is multi-rounds
Go to expertiza/app/models/assignment.rb, find the following function
<pre>
def current_stage_name(topic_id = nil)
if self.staggered_deadline?
return (topic_id.nil? ? 'Unknown' : get_current_stage(topic_id))
end
due_date = find_current_stage(topic_id)
</pre>
check rounds, if >=2, then checkbox can be clicked.

2. Then, Edit the database
Go to DB, add an attribute named 'is_second_round_allowed_checked' to assignment

3. Finally, add the function
Go to expertiza/app/models/assignment.rb, add a function called 'allow_second_round_review'. When rounds <2, do nothing; else, allow second_round reviews if box checked.

4. Change the view of student_review as following:
<pre>
<% if check_reviewable_topics(@assignment) or @assignment.get_current_stage(@topic_id) == "Finished" %>
<%= render :partial => 'responses', :locals => {:mappings => @review_mappings, :title => 'Review'} %>
<% if @assignment.number_of_current_round(@topic_id) == 1 or (@assignment.number_of_current_round(@topic_id) >= 2 and @assignment.allow_doing_subsequent_review_without_first_round) %>
<% if @assignment.dynamic_reviewer_assignment? %>
<% if @num_reviews_in_progress >= Assignment.max_outstanding_reviews %>
<br><br>
<span>Note: You can't have more than 2 outstanding reviews. You must complete one of your outstanding reviews before selecting another.</span>
<% elsif @assignment.num_reviews && @assignment.num_reviews >= 0 && @num_reviews_total >= @assignment.num_reviews%>
<br><br>
<span>Note: You can't do more than <%=@assignment.num_reviews%> reviews according to assignment policy.</span>
<%else %>
<%= render :partial => 'set_dynamic_review', :locals => {:assignment => @assignment, :participant => @participant} %>
<% end %>
<% end %>
<% end %>
<% else %>
</pre>

=Test Plan=
We plan to write a feature test for the project. Go to expertiza/spec/features folder, add a file named 'Allow_second_round_review'. Below is the details of our test.
==Test checkbox(Instructor side)==
1. Log in as instructor

2. Navigate to “Manage…”,then “Assignments”

3. Under “Actions”, choose “Edit”

4. Navigate to “Review Strategy”

5. See the checkbox “Allow student to join reviews late”
==Test task list(Student side)==
===Case 1: Check the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student cannot do the second review without the first one
===Case 2: Uncheck the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student can do the second review without the first one

=References=
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza in Github]

[[Expertiza documentation]]

[[Documentation on Database Tables]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-12-08T00:51:53Z

Yyang53: /* Code Level Design */

=Introduction=
Expertiza supports multi-round peer reviews. Currently, in this situation, student who did not do the previous round peer reviews can still do the subsequent round peer reviews, but will lose about 50 points according to the deduction policy. Therefore, it will be fairer to provide instructor an option to decide whether a student can do the subsequent round peer reviews when s/he did not do the previous round peer reviews.

=Design Plan=
==UI Improvement==
In assignment#edit page “Review strategy” tab, add a checkbox (e.g., “Allow student to join reviews late”*) to allow instructor to decide whether students can do the second round peer reviews without the first round peer reviews; by default this box is unchecked and it only appears when there are multi-round peer reviews.
*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
==Functionality Implementation==
===Explanation===
Currently, when students didn't request enough reviews(e.g. Each student is required to do at least 2 reviews, but s/he only request one in the first round), they can still request more reviews in the second round, but will lose points due to lack of first round reviews. Now, we want to add a functionality to split the case. Below is the flow chart that explains the improvement. * Note that whether submit or not doesn't matter, as long as request, it counts.

[[File:Diagram.png]]
===Code Level Design===
1. First, check whether a certain assignment is multi-rounds
Go to expertiza/app/models/assignment.rb, find the following function
<pre>
def num_review_rounds
due_dates = AssignmentDueDate.where(parent_id: self.id)
rounds = 0
due_dates.each do |due_date|
rounds = due_date.round if due_date.round > rounds
end
rounds
end
</pre>
check rounds, if >=2, then checkbox will be added.

2. Then, Edit the database
Go to DB, add an attribute named 'is_second_round_allowed_checked' to assignment

3. Finally, add the function
Go to expertiza/app/models/assignment.rb, add a function called 'allow_second_round_review'. When rounds <2, do nothing; else, allow second_round reviews if box checked.

4. Change the view of student_review as following:
<pre>
<% if check_reviewable_topics(@assignment) or @assignment.get_current_stage(@topic_id) == "Finished" %>
<%= render :partial => 'responses', :locals => {:mappings => @review_mappings, :title => 'Review'} %>
<% if @assignment.number_of_current_round(@topic_id) == 1 or (@assignment.number_of_current_round(@topic_id) >= 2 and @assignment.allow_doing_subsequent_review_without_first_round) %>
<% if @assignment.dynamic_reviewer_assignment? %>
<% if @num_reviews_in_progress >= Assignment.max_outstanding_reviews %>
<br><br>
<span>Note: You can't have more than 2 outstanding reviews. You must complete one of your outstanding reviews before selecting another.</span>
<% elsif @assignment.num_reviews && @assignment.num_reviews >= 0 && @num_reviews_total >= @assignment.num_reviews%>
<br><br>
<span>Note: You can't do more than <%=@assignment.num_reviews%> reviews according to assignment policy.</span>
<%else %>
<%= render :partial => 'set_dynamic_review', :locals => {:assignment => @assignment, :participant => @participant} %>
<% end %>
<% end %>
<% end %>
<% else %>
</pre>

=Test Plan=
We plan to write a feature test for the project. Go to expertiza/spec/features folder, add a file named 'Allow_second_round_review'. Below is the details of our test.
==Test checkbox(Instructor side)==
1. Log in as instructor

2. Navigate to “Manage…”,then “Assignments”

3. Under “Actions”, choose “Edit”

4. Navigate to “Review Strategy”

5. See the checkbox “Allow student to join reviews late”
==Test task list(Student side)==
===Case 1: Check the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student cannot do the second review without the first one
===Case 2: Uncheck the checkbox===
1. Log in as student

2. Navigate to “Assignments”

3. Choose an assignment

4. Navigate to “Others’ work”

5. Student can do the second review without the first one

=References=
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza in Github]

[[Expertiza documentation]]

[[Documentation on Database Tables]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-11-20T02:53:11Z

Yyang53:

==Introduction==
Expertiza supports multi-round peer review. Currently, in this situation, student who did not do the previous round peer review can still do the subsequent round peer review. According to the deduction policy, some reviewees might lose points because of the reviewers who miss the previous round peer review. Therefore, it will be fairer to provide instructor an option which can decide whether a student can do the subsequent round peer review when s/he did not do the previous round peer review.

==Design Plan==
===UI Improvement===
In assignment#edit page “Review strategy” tab, add an option (e.g., “Allow student to join reviews late”*) to allow students to do the second round peer reviews without the first round peer review; by default this option is unchecked. Please note that this option should appear only if there are multi-round peer reviews. If there is only one round peer review, do not show this option.

*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
===Functionality Implementation===
====Visual Aids====
*Flow Chart
[[File:Diagram.png]]
*UML
====Related Problems====
====Code Level Design====
==Test Plan==

==References==
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza Github]

[http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables]

[[http://wiki.expertiza.ncsu.edu/index.php/Main_Page]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-11-20T02:52:55Z

Yyang53:

==Introduction==
Expertiza supports multi-round peer review. Currently, in this situation, student who did not do the previous round peer review can still do the subsequent round peer review. According to the deduction policy, some reviewees might lose points because of the reviewers who miss the previous round peer review. Therefore, it will be fairer to provide instructor an option which can decide whether a student can do the subsequent round peer review when s/he did not do the previous round peer review.

==Design Plan==
===UI Improvement===
In assignment#edit page “Review strategy” tab, add an option (e.g., “Allow student to join reviews late”*) to allow students to do the second round peer reviews without the first round peer review; by default this option is unchecked. Please note that this option should appear only if there are multi-round peer reviews. If there is only one round peer review, do not show this option.

*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
===Functionality Implementation===
====Visual Aids====
*Flow Chart
[[File:Diagram.png]]
*UML
====Related Problems====
====Code Level Design====
==Test Plan==

==References==
[https://github.com/expertiza/expertiza/blob/master/app/views/assignments/edit/_review_strategy.html.erb assignments/edit/_review_strategy.html.erb]

[https://github.com/expertiza/expertiza/blob/master/app/views/student_task/list.html.erb student_task/list.html.erb]

[https://github.com/expertiza/expertiza Expertiza Github]

[wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables]

[[http://wiki.expertiza.ncsu.edu/index.php/Main_Page]]

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-11-20T02:51:23Z

Yyang53:

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-11-20T02:22:36Z

Yyang53: /* Introduction */

==Introduction==
Expertiza supports multi-round peer review. Currently, in this situation, student who did not do the previous round peer review can still do the subsequent round peer review. According to the deduction policy, some reviewees might lose points because of the reviewers who miss the previous round peer review. Therefore, it will be fairer to provide instructor an option which can decide whether a student can do the subsequent round peer review when s/he did not do the previous round peer review.

==Design Plan==
===UI Improvement===
In assignment#edit page “Review strategy” tab, add an option (e.g., “Allow student to join reviews late”*) to allow students to do the second round peer reviews without the first round peer review; by default this option is unchecked. Please note that this option should appear only if there are multi-round peer reviews. If there is only one round peer review, do not show this option.

*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
===Functionality Implementation===
====Visual Aids====
*Flow Chart
[[File:Diagram.png]]
*UML
====Related Problems====
====Code Level Design====
==Test Plan==

== Related Files ==
assignments/edit/_review_strategy.html.erb
student_task/list.html.erb

CSC/ECE 517 Fall 2018 E1870 Warn of deadlines and enforce them

2018-11-20T02:21:09Z

Yyang53:

==Introduction==
Currently, student who did not do the previous round peer review can still do the subsequent round peer review. According to the deduction policy, some reviewees might lose points because of the reviewers who miss the previous round peer review. Therefore, it will be fairer to provide instructor an option which can decide whether a student can do the subsequent round peer review when s/he did not do the previous round peer review.

==Design Plan==
===UI Improvement===
In assignment#edit page “Review strategy” tab, add an option (e.g., “Allow student to join reviews late”*) to allow students to do the second round peer reviews without the first round peer review; by default this option is unchecked. Please note that this option should appear only if there are multi-round peer reviews. If there is only one round peer review, do not show this option.

*Before
[[File:Before1.png]]
*After
[[File:Afterr1.png]]
===Functionality Implementation===
====Visual Aids====
*Flow Chart
[[File:Diagram.png]]
*UML
====Related Problems====
====Code Level Design====
==Test Plan==

== Related Files ==
assignments/edit/_review_strategy.html.erb
student_task/list.html.erb

E1850. Write unit tests for review response map.rb team100

2018-11-09T19:03:32Z

Yyang53: /* Background */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based on peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students who enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of their works.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage edge cases.
*Achieve high branch coverage. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Test Plan ==
=== Mock instance ===
We mock the necessary instances for the test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, is_submitted: true) }
let(:metareview_response_map) { MetareviewResponseMap.new(reviewed_object_id: 1) }
let(:student) { build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:questionnaire) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) { User.new(id: 1, name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
</pre>

== Implementation ==
Write test for the methods in review_response_map.rb.

=== Questionnaire ===
Questionnaire method returns a questionnaire associated with an assignment.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire)
expect(review_response_map.questionnaire(1)).to eq(questionnaire)
end
</pre>

=== Get title ===
Get_title method returns the title.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== Delete ===
Delete method deletes the feedback_response_map and metareview_response_map and return review_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== Export fields ===
Export_fields method which shows the title of export csv file, "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('options')).to eq(["contributor", "reviewed by"])
end
</pre>

=== Export ===
Export method exports the name of reviewer and reviewee and return the map.
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== Import ===
Import method allows user to import the csv file and check it. After that, it returns the name of reviewers.
<pre>
it '#import' do
row_hash = {reviewee: "name", reviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Cannot find reviewee user.")
# when reviewee user exists but reviewee user is not a participant in this assignment
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Reviewee user is not a participant in this assignment.")
# when reviewee user exists and reviewee user is a participant in this assignment
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name1").and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Cannot find reviewer user.")
## when reviewer user exist
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
### when reviewer user is not a participant in this assignment.
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Reviewer user is not a participant in this assignment.")
### when reviewer user is a participant in this assignment.
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, session, 1)).to eq(["name1"])
end
</pre>

=== Show feedback ===
Show_feedback method returns the html associated with response.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== Metareview response maps ===
Metareview_response_maps method returns metareview_list associated with responses.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map])
end
</pre>

=== Get responses for team round ===
Get_responses_for_team_round method returns the responses associated with team and round.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== Final versions from reviewer ===
Final_versions_from_reviewer method returns the questionnaire and response ids associated with reviewer.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq("review round1": {questionnaire_id: 1, response_ids: [1]}, "review round2": {questionnaire_id: 1, response_ids: [2]})
end
</pre>

=== Review response report ===
Review_response_report method returns the participants associated with assignment.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq([assignment_participant])
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq([assignment_participant])
end
</pre>

=== Email ===
Email method can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== Prepare final review versions ===
Prepare_final_review_versions method returns the final review versions.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq("review round1": {questionnaire_id: 1, response_ids: [1]}, "review round2": {questionnaire_id: 1, response_ids: [2]})
# when round = nil
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq(review: {questionnaire_id: nil, response_ids: [3]})
end
</pre>

=== Prepare review response ===
Prepare_review_response method returns the response id associated with assignment.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==
app/models/review_response_map.rb <br>
100.0 % covered <br>
102 relevant lines. 102 lines covered and 0 lines missed.

Full video for this test can be found at https://drive.google.com/file/d/18vr3q2dCyh3_tsFLH8w9y6Y9uhdz0Ljj/view?usp=sharing

== External Links ==
https://github.com/Sauve-moi/expertiza

E1850. Write unit tests for review response map.rb team100

2018-11-09T19:00:57Z

Yyang53: /* Import */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage edge cases.
*Achieve high branch coverage. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Test Plan ==
=== Mock instance ===
We mock the necessary instances for the test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, is_submitted: true) }
let(:metareview_response_map) { MetareviewResponseMap.new(reviewed_object_id: 1) }
let(:student) { build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:questionnaire) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) { User.new(id: 1, name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
</pre>

== Implementation ==
Write test for the methods in review_response_map.rb.

=== Questionnaire ===
Questionnaire method returns a questionnaire associated with an assignment.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire)
expect(review_response_map.questionnaire(1)).to eq(questionnaire)
end
</pre>

=== Get title ===
Get_title method returns the title.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== Delete ===
Delete method deletes the feedback_response_map and metareview_response_map and return review_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== Export fields ===
Export_fields method which shows the title of export csv file, "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('options')).to eq(["contributor", "reviewed by"])
end
</pre>

=== Export ===
Export method exports the name of reviewer and reviewee and return the map.
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== Import ===
Import method allows user to import the csv file and check it. After that, it returns the name of reviewers.
<pre>
it '#import' do
row_hash = {reviewee: "name", reviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Cannot find reviewee user.")
# when reviewee user exists but reviewee user is not a participant in this assignment
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Reviewee user is not a participant in this assignment.")
# when reviewee user exists and reviewee user is a participant in this assignment
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name1").and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Cannot find reviewer user.")
## when reviewer user exist
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
### when reviewer user is not a participant in this assignment.
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Reviewer user is not a participant in this assignment.")
### when reviewer user is a participant in this assignment.
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, session, 1)).to eq(["name1"])
end
</pre>

=== Show feedback ===
Show_feedback method returns the html associated with response.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== Metareview response maps ===
Metareview_response_maps method returns metareview_list associated with responses.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map])
end
</pre>

=== Get responses for team round ===
Get_responses_for_team_round method returns the responses associated with team and round.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== Final versions from reviewer ===
Final_versions_from_reviewer method returns the questionnaire and response ids associated with reviewer.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq("review round1": {questionnaire_id: 1, response_ids: [1]}, "review round2": {questionnaire_id: 1, response_ids: [2]})
end
</pre>

=== Review response report ===
Review_response_report method returns the participants associated with assignment.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq([assignment_participant])
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq([assignment_participant])
end
</pre>

=== Email ===
Email method can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== Prepare final review versions ===
Prepare_final_review_versions method returns the final review versions.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq("review round1": {questionnaire_id: 1, response_ids: [1]}, "review round2": {questionnaire_id: 1, response_ids: [2]})
# when round = nil
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq(review: {questionnaire_id: nil, response_ids: [3]})
end
</pre>

=== Prepare review response ===
Prepare_review_response method returns the response id associated with assignment.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==
app/models/review_response_map.rb <br>
100.0 % covered <br>
102 relevant lines. 102 lines covered and 0 lines missed.

Full video for this test can be found at https://drive.google.com/file/d/18vr3q2dCyh3_tsFLH8w9y6Y9uhdz0Ljj/view?usp=sharing

== External Links ==
https://github.com/Sauve-moi/expertiza

E1850. Write unit tests for review response map.rb team100

2018-11-09T19:00:47Z

Yyang53: /* Export fields */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage edge cases.
*Achieve high branch coverage. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Test Plan ==
=== Mock instance ===
We mock the necessary instances for the test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, is_submitted: true) }
let(:metareview_response_map) { MetareviewResponseMap.new(reviewed_object_id: 1) }
let(:student) { build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:questionnaire) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) { User.new(id: 1, name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
</pre>

== Implementation ==
Write test for the methods in review_response_map.rb.

=== Questionnaire ===
Questionnaire method returns a questionnaire associated with an assignment.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire)
expect(review_response_map.questionnaire(1)).to eq(questionnaire)
end
</pre>

=== Get title ===
Get_title method returns the title.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== Delete ===
Delete method deletes the feedback_response_map and metareview_response_map and return review_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== Export fields ===
Export_fields method which shows the title of export csv file, "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('options')).to eq(["contributor", "reviewed by"])
end
</pre>

=== Export ===
Export method exports the name of reviewer and reviewee and return the map.
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== Import ===
Import method allow user to import the csv file and check it. After that, it returns the name of reviewers.
<pre>
it '#import' do
row_hash = {reviewee: "name", reviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Cannot find reviewee user.")
# when reviewee user exists but reviewee user is not a participant in this assignment
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Reviewee user is not a participant in this assignment.")
# when reviewee user exists and reviewee user is a participant in this assignment
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name1").and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Cannot find reviewer user.")
## when reviewer user exist
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
### when reviewer user is not a participant in this assignment.
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(nil)
expect { ReviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, message = "Reviewer user is not a participant in this assignment.")
### when reviewer user is a participant in this assignment.
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, session, 1)).to eq(["name1"])
end
</pre>

=== Show feedback ===
Show_feedback method returns the html associated with response.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== Metareview response maps ===
Metareview_response_maps method returns metareview_list associated with responses.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map])
end
</pre>

=== Get responses for team round ===
Get_responses_for_team_round method returns the responses associated with team and round.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== Final versions from reviewer ===
Final_versions_from_reviewer method returns the questionnaire and response ids associated with reviewer.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq("review round1": {questionnaire_id: 1, response_ids: [1]}, "review round2": {questionnaire_id: 1, response_ids: [2]})
end
</pre>

=== Review response report ===
Review_response_report method returns the participants associated with assignment.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq([assignment_participant])
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq([assignment_participant])
end
</pre>

=== Email ===
Email method can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== Prepare final review versions ===
Prepare_final_review_versions method returns the final review versions.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq("review round1": {questionnaire_id: 1, response_ids: [1]}, "review round2": {questionnaire_id: 1, response_ids: [2]})
# when round = nil
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map])
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq(review: {questionnaire_id: nil, response_ids: [3]})
end
</pre>

=== Prepare review response ===
Prepare_review_response method returns the response id associated with assignment.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==
app/models/review_response_map.rb <br>
100.0 % covered <br>
102 relevant lines. 102 lines covered and 0 lines missed.

Full video for this test can be found at https://drive.google.com/file/d/18vr3q2dCyh3_tsFLH8w9y6Y9uhdz0Ljj/view?usp=sharing

== External Links ==
https://github.com/Sauve-moi/expertiza

E1850. Write unit tests for review response map.rb team100

2018-11-06T03:49:42Z

Yyang53: /* Unit Test Result */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage as many edge cases as we can.
*Achieve as high branch coverage as we can. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of our tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Unit Test ==
=== mock instance ===
We mock the necessary instance for all test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feed_back_response_map) { double('feed_back_response_map', reviewed_object_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:questionnaire) { ReviewQuestionnaire.new(id: 1, questions: [question], max_question_score: 5) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2 ) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1 ) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map, scores: [answer]) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:answer) { Answer.new(answer: 1, comments: 'Answer text', question_id: 1) }
let(:question) { Criterion.new(id: 1, weight: 2, break_before: true) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:metareview_response_map) { double('metareviewmap')}
let(:metareview_response_map1) { MetareviewResponseMap.new(reviewed_object_id: 1)}
let(:student) {build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:assignment_questionnaire){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 1, questionnaire_id: 1) }
let(:assignment_questionnaire1){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 2, questionnaire_id: 1) }
let(:questionnaire1) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) {User.new(id:1 , name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
let(:teams_users) {TeamsUser.new(user_id: 1, team_id: 1)}
</pre>

=== questionnaire ===
Test the questionnaire using find_by to get specific questionnaire of map.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire1)
expect(review_response_map.questionnaire(1)).to eq(questionnaire1)
end
</pre>

=== get title ===
Test the get_title method.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== delete ===
Test the delete method of review_response_map which contains delete feedback_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map1])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== export fields ===
Test the export_fields method which show the title of export csv file should be "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('Missing "_options"')).to eq(["contributor", "reviewed by"])
end
</pre>

=== export ===
Test the export method.
<pre>
it '#export' do
csv = []
parent_id = 1
_options = _options
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, _options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== import ===
Test the import method which includes errors casued by various reasons.
<pre>
it '#import' do
row_hash={reviewee: "name", reviewers: ["name1"]}
_session = nil
assignment_id = 1
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
end
</pre>

=== show feedback ===
Test show_feedback method.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== metareview response maps ===
Test metareview_response_maps method.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map1])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map1])
end
</pre>

=== get responses for team round ===
Test get_responses_for_team_round method.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
allow(team).to receive(:id).and_return(1)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== final versions from reviewer ===
Test final_versions_from_reviewer method.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
end
</pre>

=== review response report ===
Test review_response_report method.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
end
</pre>

=== email ===
Test email method which can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect{review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== prepare final review versions ===
Test the prepare_final_review_versions method.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map1).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({ review:{questionnaire_id: nil, response_ids:[3]}})
end
</pre>

=== prepare review response ===
Test prepare_review_response method.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==
app/models/review_response_map.rb <br>
100.0 % covered <br>
102 relevant lines. 102 lines covered and 0 lines missed.

E1850. Write unit tests for review response map.rb team100

2018-11-06T03:49:30Z

Yyang53: /* Unit Test Result */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage as many edge cases as we can.
*Achieve as high branch coverage as we can. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of our tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Unit Test ==
=== mock instance ===
We mock the necessary instance for all test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feed_back_response_map) { double('feed_back_response_map', reviewed_object_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:questionnaire) { ReviewQuestionnaire.new(id: 1, questions: [question], max_question_score: 5) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2 ) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1 ) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map, scores: [answer]) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:answer) { Answer.new(answer: 1, comments: 'Answer text', question_id: 1) }
let(:question) { Criterion.new(id: 1, weight: 2, break_before: true) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:metareview_response_map) { double('metareviewmap')}
let(:metareview_response_map1) { MetareviewResponseMap.new(reviewed_object_id: 1)}
let(:student) {build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:assignment_questionnaire){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 1, questionnaire_id: 1) }
let(:assignment_questionnaire1){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 2, questionnaire_id: 1) }
let(:questionnaire1) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) {User.new(id:1 , name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
let(:teams_users) {TeamsUser.new(user_id: 1, team_id: 1)}
</pre>

=== questionnaire ===
Test the questionnaire using find_by to get specific questionnaire of map.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire1)
expect(review_response_map.questionnaire(1)).to eq(questionnaire1)
end
</pre>

=== get title ===
Test the get_title method.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== delete ===
Test the delete method of review_response_map which contains delete feedback_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map1])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== export fields ===
Test the export_fields method which show the title of export csv file should be "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('Missing "_options"')).to eq(["contributor", "reviewed by"])
end
</pre>

=== export ===
Test the export method.
<pre>
it '#export' do
csv = []
parent_id = 1
_options = _options
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, _options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== import ===
Test the import method which includes errors casued by various reasons.
<pre>
it '#import' do
row_hash={reviewee: "name", reviewers: ["name1"]}
_session = nil
assignment_id = 1
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
end
</pre>

=== show feedback ===
Test show_feedback method.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== metareview response maps ===
Test metareview_response_maps method.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map1])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map1])
end
</pre>

=== get responses for team round ===
Test get_responses_for_team_round method.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
allow(team).to receive(:id).and_return(1)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== final versions from reviewer ===
Test final_versions_from_reviewer method.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
end
</pre>

=== review response report ===
Test review_response_report method.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
end
</pre>

=== email ===
Test email method which can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect{review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== prepare final review versions ===
Test the prepare_final_review_versions method.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map1).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({ review:{questionnaire_id: nil, response_ids:[3]}})
end
</pre>

=== prepare review response ===
Test prepare_review_response method.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==
app/models/review_response_map.rb <br>
100.0 % covered
102 relevant lines. 102 lines covered and 0 lines missed.

E1850. Write unit tests for review response map.rb team100

2018-11-06T03:49:11Z

Yyang53: /* Unit Test Result */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage as many edge cases as we can.
*Achieve as high branch coverage as we can. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of our tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Unit Test ==
=== mock instance ===
We mock the necessary instance for all test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feed_back_response_map) { double('feed_back_response_map', reviewed_object_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:questionnaire) { ReviewQuestionnaire.new(id: 1, questions: [question], max_question_score: 5) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2 ) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1 ) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map, scores: [answer]) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:answer) { Answer.new(answer: 1, comments: 'Answer text', question_id: 1) }
let(:question) { Criterion.new(id: 1, weight: 2, break_before: true) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:metareview_response_map) { double('metareviewmap')}
let(:metareview_response_map1) { MetareviewResponseMap.new(reviewed_object_id: 1)}
let(:student) {build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:assignment_questionnaire){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 1, questionnaire_id: 1) }
let(:assignment_questionnaire1){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 2, questionnaire_id: 1) }
let(:questionnaire1) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) {User.new(id:1 , name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
let(:teams_users) {TeamsUser.new(user_id: 1, team_id: 1)}
</pre>

=== questionnaire ===
Test the questionnaire using find_by to get specific questionnaire of map.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire1)
expect(review_response_map.questionnaire(1)).to eq(questionnaire1)
end
</pre>

=== get title ===
Test the get_title method.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== delete ===
Test the delete method of review_response_map which contains delete feedback_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map1])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== export fields ===
Test the export_fields method which show the title of export csv file should be "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('Missing "_options"')).to eq(["contributor", "reviewed by"])
end
</pre>

=== export ===
Test the export method.
<pre>
it '#export' do
csv = []
parent_id = 1
_options = _options
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, _options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== import ===
Test the import method which includes errors casued by various reasons.
<pre>
it '#import' do
row_hash={reviewee: "name", reviewers: ["name1"]}
_session = nil
assignment_id = 1
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
end
</pre>

=== show feedback ===
Test show_feedback method.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== metareview response maps ===
Test metareview_response_maps method.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map1])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map1])
end
</pre>

=== get responses for team round ===
Test get_responses_for_team_round method.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
allow(team).to receive(:id).and_return(1)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== final versions from reviewer ===
Test final_versions_from_reviewer method.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
end
</pre>

=== review response report ===
Test review_response_report method.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
end
</pre>

=== email ===
Test email method which can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect{review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== prepare final review versions ===
Test the prepare_final_review_versions method.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map1).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({ review:{questionnaire_id: nil, response_ids:[3]}})
end
</pre>

=== prepare review response ===
Test prepare_review_response method.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==
app/models/review_response_map.rb
100.0 % covered
102 relevant lines. 102 lines covered and 0 lines missed.

E1850. Write unit tests for review response map.rb team100

2018-11-06T03:45:54Z

Yyang53: /* prepare final review versions */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage as many edge cases as we can.
*Achieve as high branch coverage as we can. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of our tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Unit Test ==
=== mock instance ===
We mock the necessary instance for all test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feed_back_response_map) { double('feed_back_response_map', reviewed_object_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:questionnaire) { ReviewQuestionnaire.new(id: 1, questions: [question], max_question_score: 5) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2 ) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1 ) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map, scores: [answer]) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:answer) { Answer.new(answer: 1, comments: 'Answer text', question_id: 1) }
let(:question) { Criterion.new(id: 1, weight: 2, break_before: true) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:metareview_response_map) { double('metareviewmap')}
let(:metareview_response_map1) { MetareviewResponseMap.new(reviewed_object_id: 1)}
let(:student) {build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:assignment_questionnaire){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 1, questionnaire_id: 1) }
let(:assignment_questionnaire1){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 2, questionnaire_id: 1) }
let(:questionnaire1) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) {User.new(id:1 , name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
let(:teams_users) {TeamsUser.new(user_id: 1, team_id: 1)}
</pre>

=== questionnaire ===
Test the questionnaire using find_by to get specific questionnaire of map.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire1)
expect(review_response_map.questionnaire(1)).to eq(questionnaire1)
end
</pre>

=== get title ===
Test the get_title method.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== delete ===
Test the delete method of review_response_map which contains delete feedback_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map1])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== export fields ===
Test the export_fields method which show the title of export csv file should be "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('Missing "_options"')).to eq(["contributor", "reviewed by"])
end
</pre>

=== export ===
Test the export method.
<pre>
it '#export' do
csv = []
parent_id = 1
_options = _options
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, _options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== import ===
Test the import method which includes errors casued by various reasons.
<pre>
it '#import' do
row_hash={reviewee: "name", reviewers: ["name1"]}
_session = nil
assignment_id = 1
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
end
</pre>

=== show feedback ===
Test show_feedback method.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== metareview response maps ===
Test metareview_response_maps method.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map1])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map1])
end
</pre>

=== get responses for team round ===
Test get_responses_for_team_round method.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
allow(team).to receive(:id).and_return(1)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== final versions from reviewer ===
Test final_versions_from_reviewer method.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
end
</pre>

=== review response report ===
Test review_response_report method.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
end
</pre>

=== email ===
Test email method which can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect{review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== prepare final review versions ===
Test the prepare_final_review_versions method.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map1).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({ review:{questionnaire_id: nil, response_ids:[3]}})
end
</pre>

=== prepare review response ===
Test prepare_review_response method.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==

E1850. Write unit tests for review response map.rb team100

2018-11-06T03:45:37Z

Yyang53: /* review response report */

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage as many edge cases as we can.
*Achieve as high branch coverage as we can. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of our tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Unit Test ==
=== mock instance ===
We mock the necessary instance for all test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feed_back_response_map) { double('feed_back_response_map', reviewed_object_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:questionnaire) { ReviewQuestionnaire.new(id: 1, questions: [question], max_question_score: 5) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2 ) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1 ) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map, scores: [answer]) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:answer) { Answer.new(answer: 1, comments: 'Answer text', question_id: 1) }
let(:question) { Criterion.new(id: 1, weight: 2, break_before: true) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:metareview_response_map) { double('metareviewmap')}
let(:metareview_response_map1) { MetareviewResponseMap.new(reviewed_object_id: 1)}
let(:student) {build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:assignment_questionnaire){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 1, questionnaire_id: 1) }
let(:assignment_questionnaire1){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 2, questionnaire_id: 1) }
let(:questionnaire1) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) {User.new(id:1 , name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
let(:teams_users) {TeamsUser.new(user_id: 1, team_id: 1)}
</pre>

=== questionnaire ===
Test the questionnaire using find_by to get specific questionnaire of map.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire1)
expect(review_response_map.questionnaire(1)).to eq(questionnaire1)
end
</pre>

=== get title ===
Test the get_title method.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== delete ===
Test the delete method of review_response_map which contains delete feedback_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map1])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== export fields ===
Test the export_fields method which show the title of export csv file should be "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('Missing "_options"')).to eq(["contributor", "reviewed by"])
end
</pre>

=== export ===
Test the export method.
<pre>
it '#export' do
csv = []
parent_id = 1
_options = _options
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, _options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== import ===
Test the import method which includes errors casued by various reasons.
<pre>
it '#import' do
row_hash={reviewee: "name", reviewers: ["name1"]}
_session = nil
assignment_id = 1
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
end
</pre>

=== show feedback ===
Test show_feedback method.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== metareview response maps ===
Test metareview_response_maps method.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map1])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map1])
end
</pre>

=== get responses for team round ===
Test get_responses_for_team_round method.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
allow(team).to receive(:id).and_return(1)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== final versions from reviewer ===
Test final_versions_from_reviewer method.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
end
</pre>

=== review response report ===
Test review_response_report method.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
review_user = nil
allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
end
</pre>

=== email ===
Test email method which can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect{review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== prepare final review versions ===
Test the prepare_final_review_versions method.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map1).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
# when round = nil
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])

allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({ review:{questionnaire_id: nil, response_ids:[3]}})
end
</pre>

=== prepare review response ===
Test prepare_review_response method.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==

E1850. Write unit tests for review response map.rb team100

2018-11-06T03:45:04Z

Yyang53:

This wiki page is for the description of unit test for E1850 OSS assignment for Fall 2018, CSC/ECE 517.

== Background ==
Expertiza is an open source web based peer review system developed and maintained by students and faculty members at North Carolina State University. It enables students enrolled in a particular course to form online teams, complete assignments, review other's work and receive feedbacks of your work.

== Problem ==
Review_response_map.rb is used to prepare data for peer review. But there are no unit tests for it.

== Work to be done ==
*Create a new file named review_response_map_spec.rb under spec/models folder
*Write RSpec unit tests to make the path coverage above 90%.
*Coverage as many edge cases as we can.
*Achieve as high branch coverage as we can. Use the mutant-rspec gem to measure test thoroughness and fault-finding capability of our tests.

== Files Created ==
*spec/models/review_response_map_spec.rb

== Unit Test ==
=== mock instance ===
We mock the necessary instance for all test in the beginning of test file.
<pre>
let(:team) { build(:assignment_team, id: 1, name: 'team no name', assignment: assignment, users: [student], parent_id: 1) }
let(:team1) { build(:assignment_team, id: 2, name: 'team has name', assignment: assignment, users: [student]) }
let(:review_response_map) { build(:review_response_map, id: 1, assignment: assignment, reviewer: participant, reviewee: team, reviewed_object_id: 1) }
let(:review_response_map1) { build(:review_response_map, id: 2, assignment: assignment, reviewer: participant1, reviewee: team1, reviewed_object_id: 1) }
let(:feed_back_response_map) { double('feed_back_response_map', reviewed_object_id: 1) }
let(:participant) { build(:participant, id: 1, parent_id: 1, user: build(:student, parent_id: 1, name: 'no name', fullname: 'no one')) }
let(:participant1) { build(:participant, id: 2, parent_id: 2, user: build(:student, parent_id: 1, name: 'has name', fullname: 'has one')) }
let(:questionnaire) { ReviewQuestionnaire.new(id: 1, questions: [question], max_question_score: 5) }
let(:assignment) { build(:assignment, id: 1, name: 'Test Assgt', rounds_of_reviews: 2 ) }
let(:assignment1) { build(:assignment, id: 2, name: 'Test Assgt', rounds_of_reviews: 1 ) }
let(:response) { build(:response, id: 1, map_id: 1, round: 1, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:response1) { build(:response, id: 2, map_id: 1, round: 2, response_map: review_response_map, scores: [answer]) }
let(:response2) { build(:response, id: 3, map_id: 1, round: nil, response_map: review_response_map, scores: [answer], is_submitted: true) }
let(:answer) { Answer.new(answer: 1, comments: 'Answer text', question_id: 1) }
let(:question) { Criterion.new(id: 1, weight: 2, break_before: true) }
let(:feedback) { FeedbackResponseMap.new(id: 1, reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1) }
let(:metareview_response_map) { double('metareviewmap')}
let(:metareview_response_map1) { MetareviewResponseMap.new(reviewed_object_id: 1)}
let(:student) {build(:student, id: 1, fullname: 'no one', email: 'expertiza@mailinator.com') }
let(:assignment_questionnaire){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 1, questionnaire_id: 1) }
let(:assignment_questionnaire1){ AssignmentQuestionnaire.new(assignment_id: 1, used_in_round: 2, questionnaire_id: 1) }
let(:questionnaire1) { Questionnaire.new(id: 1, type: 'ReviewQuestionnaire') }
let(:response_map) { ResponseMap.new(id: 1, reviewed_object_id: 1, reviewee_id: 1, reviewer_id: 1, type: "ReviewResponseMap", response: [response], calibrate_to: 0) }
let(:user) {User.new(id:1 , name: "name", fullname: 'fullname') }
let(:user1) { User.new(id: 2, name: "name1", fullname: 'fullname') }
let(:assignment_participant) { AssignmentParticipant.new(user_id: 1, parent_id: 1) }
let(:assignment_participant1) { AssignmentParticipant.new(id: 1, user_id: 2, parent_id: 1) }
let(:teams_users) {TeamsUser.new(user_id: 1, team_id: 1)}
</pre>

=== questionnaire ===
Test the questionnaire using find_by to get specific questionnaire of map.
<pre>
it '#questionnaire' do
round = 1
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Questionnaire).to receive(:find_by).with(id: 1).and_return(questionnaire1)
expect(review_response_map.questionnaire(1)).to eq(questionnaire1)
end
</pre>

=== get title ===
Test the get_title method.
<pre>
it '#get_title' do
expect(review_response_map.get_title).to eq("Review")
end
</pre>

=== delete ===
Test the delete method of review_response_map which contains delete feedback_response_map.
<pre>
it '#delete' do
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([feedback])
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map1])
expect(review_response_map.delete).to equal(review_response_map)
end
</pre>

=== export fields ===
Test the export_fields method which show the title of export csv file should be "contributor" and "reviewed by".
<pre>
it '#export_fields' do
expect(ReviewResponseMap.export_fields('Missing "_options"')).to eq(["contributor", "reviewed by"])
end
</pre>

=== export ===
Test the export method.
<pre>
it '#export' do
csv = []
parent_id = 1
_options = _options
allow(ReviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([review_response_map, review_response_map1])
expect(ReviewResponseMap.export(csv, parent_id, _options)).to eq([review_response_map1, review_response_map])
end
</pre>

=== import ===
Test the import method which includes errors casued by various reasons.
<pre>
it '#import' do
row_hash={reviewee: "name", reviewers: ["name1"]}
_session = nil
assignment_id = 1
allow(User).to receive(:find_by).with(name: "name").and_return(user)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(assignment_participant)
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(team)
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
# when reviewee_team = nil
allow(AssignmentTeam).to receive(:team).with(assignment_participant).and_return(nil)
allow(AssignmentTeam).to receive(:create).and_return(double('team', id: 1))
allow(TeamsUser).to receive(:create).with(team_id: 1, user_id: 1).and_return(double('teams_users', id: 1, team_id: 1, user_id: 1))
allow(TeamNode).to receive(:create).with(parent_id: assignment_id, node_object_id: 1).and_return(double('team_node', id: 1, parent_id: 1, node_object_id: 1))
allow(TeamUserNode).to receive(:create).with(parent_id: 1, node_object_id: 1).and_return(double('team_user_node', id: 1, parent_id: 1, node_object_id: 1))
allow(User).to receive(:find_by).with(name: "name1").and_return(user1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 2, parent_id: 1).and_return(assignment_participant1)
allow(ReviewResponseMap).to receive(:find_or_create_by).with(reviewed_object_id: 1, reviewer_id: 1, reviewee_id: 1, calibrate_to: false).and_return(review_response_map)
expect(ReviewResponseMap.import(row_hash, _session, 1)).to eq(["name1"])
end
</pre>

=== show feedback ===
Test show_feedback method.
<pre>
it '#show_feedback' do
allow(review_response_map).to receive(:response).and_return([response])
allow(Response).to receive(:find).and_return(response)
allow(FeedbackResponseMap).to receive(:find_by).with(reviewed_object_id: 1).and_return(feedback)
allow(feedback).to receive(:response).and_return([response])
expect(review_response_map.show_feedback(response)).to eq("<table width=\"100%\"><tr><td align=\"left\" width=\"70%\"><b>Review </b>"\
"   <a href=\"#\" name= \"review_1Link\" onClick=\"toggleElement('review_1','review');return false;\">"\
"show review</a></td><td align=\"left\"><b>Last Reviewed:</b><span>Not available</span></td></tr></table><table id=\"review_1\""\
" style=\"display: none;\" class=\"table table-bordered\"><tr><td><b>"\
"Additional Comment: </b></td></tr></table>")
end
</pre>

=== metareview response maps ===
Test metareview_response_maps method.
<pre>
it '#metareview_response_maps' do
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id: 1).and_return([metareview_response_map1])
expect(review_response_map.metareview_response_maps).to eq([metareview_response_map1])
end
</pre>

=== get responses for team round ===
Test get_responses_for_team_round method.
<pre>
it '#get_responses_for_team_round' do
allow(Team).to receive(:find).and_return(team)
allow(team).to receive(:id).and_return(1)
round = 1
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id, type: "ReviewResponseMap").and_return([response_map])
expect(ReviewResponseMap.get_responses_for_team_round(team, 1)).to eq([response])
end
</pre>

=== final versions from reviewer ===
Test final_versions_from_reviewer method.
<pre>
it '#final_versions_from_reviewer' do
reviewer_id = 1
allow(ReviewResponseMap).to receive(:where).with(reviewer_id: 1).and_return([review_response_map])
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(participant).to receive(:parent_id).and_return(1)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.final_versions_from_reviewer(1)).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
end
</pre>

=== review response report ===
Test review_response_report method.
<pre>
it '#review_response_report' do
id = 1
type = "MetareviewResponseMap"
reviewer_id = 1
user_ids = []
review_user = user
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
# allow(User).to receive(:where).with('fullname LIKE ?', '%' + review_user[:fullname] + '%').and_return([user])
# allow([user]).to receive(:select).with('DISTINCT id').and_return([user])

allow(User).to receive_message_chain(:select, :where).and_return([user])
allow(AssignmentParticipant).to receive(:where).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
review_user = nil
# allow(ResponseMap).to receive(:where).with('reviewed_object_id = ? and type = ? and calibrate_to = ?', id, type, 0).and_return([response_map])
# allow([response_map]).to receive(:select).with('DISTINCT reviewer_id').and_return([response_map])

allow(ResponseMap).to receive_message_chain(:select, :where).and_return([response_map])
allow([response_map]).to receive(:reviewer_id).and_return(1)
allow(AssignmentParticipant).to receive(:find).with(1).and_return([assignment_participant])
allow(Participant).to receive(:sort_by_name).and_return([assignment_participant])
expect(ReviewResponseMap.review_response_report(id, Assignment.find(Participant.find(reviewer_id).parent_id), type, review_user)).to eq( [assignment_participant] )
end
</pre>

=== email ===
Test email method which can successfully send an email.
<pre>
it '#email' do
reviewer_id = 1
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
allow(AssignmentTeam).to receive(:users).and_return(student)
allow(User).to receive(:find).with(1).and_return(student)
review_response_map.reviewee_id = 1
defn = {body: {type: "Peer Review", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect{review_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }.to change { ActionMailer::Base.deliveries.count }.by (1)
end
</pre>

=== prepare final review versions ===
Test the prepare_final_review_versions method.
<pre>
it '#prepare_final_review_versions' do
review_final_versions = {}
reviewer_id = 1
allow(metareview_response_map1).to receive(:id).and_return(1)
allow(Participant).to receive(:find).with(1).and_return(participant)
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
allow(Response).to receive(:where).with(map_id: 1, round: 2).and_return([response1])
allow(assignment).to receive(:review_questionnaire_id).with(2).and_return(1)
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({"review round1":{questionnaire_id: 1, response_ids:[1]}, "review round2":{questionnaire_id: 1, response_ids:[2] }})
# when round = nil
reviewer_id = 2
allow(Participant).to receive(:find).with(2).and_return(participant1)
allow(Assignment).to receive(:find).with(2).and_return(assignment1)
allow(MetareviewResponseMap).to receive(:where).with(reviewed_object_id:1).and_return([metareview_response_map1])

allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_final_review_versions(Assignment.find(Participant.find(reviewer_id).parent_id), MetareviewResponseMap.where(reviewed_object_id: 1))).to eq({ review:{questionnaire_id: nil, response_ids:[3]}})
end
</pre>

=== prepare review response ===
Test prepare_review_response method.
<pre>
it '#prepare_review_response' do
review_final_versions = {}
review_response_map.id = 1
round = 1
maps = [review_response_map]
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(Response).to receive(:where).with(map_id: 1, round: 1).and_return([response])
allow(assignment).to receive(:review_questionnaire_id).with(1).and_return(1)
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([1])
round = nil
allow(Assignment).to receive(:find).with(1).and_return(assignment)
allow(assignment).to receive(:review_questionnaire_id).with(nil).and_return(1)
allow(Response).to receive(:where).with(map_id: 1).and_return([response2])
expect(ReviewResponseMap.prepare_review_response(assignment, maps, review_final_versions, round)).to eq([3])
end
</pre>

==Running Rspec==
The tests can be run on the terminal from inside the expertiza folder using following commands:

<pre>
rspec spec/models/review_response_map_spec.rb
</pre>

==Unit Test Result==

E1850. Write unit tests for review response map.rb team100

2018-11-06T03:17:40Z

Yyang53:

E1850. Write unit tests for review response map.rb team100

2018-11-06T02:46:54Z

Yyang53:

E1850. Write unit tests for review response map.rb team100

2018-11-02T21:08:09Z

Yyang53: Created page with "E1850"

E1850

E1850 My project

2018-11-02T20:59:26Z

Yyang53: Created page with "The definition of review response map: to prepare the data for review assignment such as peer review."

The definition of review response map: to prepare the data for review assignment such as peer review.