Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:24:58Z

Qdibble: /* review_response_map_spec.rb */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
review_response_map.rb was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed. We test that it returns true when itself (the response map) has been metareviewed.
 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). We test that it assigns a metareviewer to a review.
 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of. We test that it finds the corresponding team for a metareview response map and a regular response map.
 
'''function: find_team_member'''
<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>
'''test: find_team_member'''
<pre>
describe 'find_team_member' do
context 'Finds the team of a reviewee' do
it 'finds the team for a metareview response map' do
allow(ResponseMap).to receive(:find_by).with(id: metareview_response_map.reviewed_object_id).and_return(metareview_response_map)
allow(AssignmentTeam).to receive(:find_by).with(id: review_response_map.reviewee_id).and_return(team)
expect(metareview_response_map.find_team_member).to eq(team)
end
it 'finds the team for a regular response map' do
allow(AssignmentTeam).to receive(:find).with(review_response_map.reviewee_id).and_return(team)
expect(review_response_map.find_team_member).to eq(team)
end
end

end
</pre>

== Running Tests ==
In the home directory of expertiza, run the following command.
<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>
This should generate a coverage report with the same coverage figures as ours.

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:24:07Z

Qdibble: /* Running Tests */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed. We test that it returns true when itself (the response map) has been metareviewed.
 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). We test that it assigns a metareviewer to a review.
 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of. We test that it finds the corresponding team for a metareview response map and a regular response map.
 
'''function: find_team_member'''
<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>
'''test: find_team_member'''
<pre>
describe 'find_team_member' do
context 'Finds the team of a reviewee' do
it 'finds the team for a metareview response map' do
allow(ResponseMap).to receive(:find_by).with(id: metareview_response_map.reviewed_object_id).and_return(metareview_response_map)
allow(AssignmentTeam).to receive(:find_by).with(id: review_response_map.reviewee_id).and_return(team)
expect(metareview_response_map.find_team_member).to eq(team)
end
it 'finds the team for a regular response map' do
allow(AssignmentTeam).to receive(:find).with(review_response_map.reviewee_id).and_return(team)
expect(review_response_map.find_team_member).to eq(team)
end
end

end
</pre>

== Running Tests ==
In the home directory of expertiza, run the following command.
<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>
This should generate a coverage report with the same coverage figures as ours.

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:23:11Z

Qdibble: /* find_team_member */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed. We test that it returns true when itself (the response map) has been metareviewed.
 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). We test that it assigns a metareviewer to a review.
 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of. We test that it finds the corresponding team for a metareview response map and a regular response map.
 
'''function: find_team_member'''
<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>
'''test: find_team_member'''
<pre>
describe 'find_team_member' do
context 'Finds the team of a reviewee' do
it 'finds the team for a metareview response map' do
allow(ResponseMap).to receive(:find_by).with(id: metareview_response_map.reviewed_object_id).and_return(metareview_response_map)
allow(AssignmentTeam).to receive(:find_by).with(id: review_response_map.reviewee_id).and_return(team)
expect(metareview_response_map.find_team_member).to eq(team)
end
it 'finds the team for a regular response map' do
allow(AssignmentTeam).to receive(:find).with(review_response_map.reviewee_id).and_return(team)
expect(review_response_map.find_team_member).to eq(team)
end
end

end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:23:00Z

Qdibble: /* find_team_member */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed. We test that it returns true when itself (the response map) has been metareviewed.
 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). We test that it assigns a metareviewer to a review.
 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of. We test that it finds the corresponding team for a metareview response map and a regular response map.

'''function: find_team_member'''
<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>
'''test: find_team_member'''
<pre>
describe 'find_team_member' do
context 'Finds the team of a reviewee' do
it 'finds the team for a metareview response map' do
allow(ResponseMap).to receive(:find_by).with(id: metareview_response_map.reviewed_object_id).and_return(metareview_response_map)
allow(AssignmentTeam).to receive(:find_by).with(id: review_response_map.reviewee_id).and_return(team)
expect(metareview_response_map.find_team_member).to eq(team)
end
it 'finds the team for a regular response map' do
allow(AssignmentTeam).to receive(:find).with(review_response_map.reviewee_id).and_return(team)
expect(review_response_map.find_team_member).to eq(team)
end
end

end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:22:19Z

Qdibble: /* find_team_member */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed. We test that it returns true when itself (the response map) has been metareviewed.
 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). We test that it assigns a metareviewer to a review.
 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

'''function: find_team_member'''
<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>
'''test: find_team_member'''
<pre>
describe 'find_team_member' do
context 'Finds the team of a reviewee' do
it 'finds the team for a metareview response map' do
allow(ResponseMap).to receive(:find_by).with(id: metareview_response_map.reviewed_object_id).and_return(metareview_response_map)
allow(AssignmentTeam).to receive(:find_by).with(id: review_response_map.reviewee_id).and_return(team)
expect(metareview_response_map.find_team_member).to eq(team)
end
it 'finds the team for a regular response map' do
allow(AssignmentTeam).to receive(:find).with(review_response_map.reviewee_id).and_return(team)
expect(review_response_map.find_team_member).to eq(team)
end
end

end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:20:21Z

Qdibble: /* assign_metareviewer */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed. We test that it returns true when itself (the response map) has been metareviewed.
 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). We test that it assigns a metareviewer to a review.
 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:19:48Z

Qdibble: /* metareviewed_by? */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed. We test that it returns true when itself (the response map) has been metareviewed.
 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:18:57Z

Qdibble: /* self.reviewer_assessments_for(team, reviewer) */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response. We test that it returns the results with the latest version number.
 
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:17:45Z

Qdibble: /* self.assessments_for(team) */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses. We test that it is able to get only assessments for submitted responses and assessments for other types of response maps.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:15:52Z

Qdibble: /* email */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:15:26Z

Qdibble: /* email */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. The function sends an email to the participant when they have a new teammate review to complete. We test to make sure the email is sent to the correct participant
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:14:09Z

Qdibble: /* get_title */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review". We test if this string is the same as typed out.

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. We test that the email delivery count is increased by one when the email method is called.
 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:13:31Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this the questionnaire method is impossible to test, ''so the test that has been written is commented out''. 
A band-aid solution is to modify questionnaire such that find_by is replaced with where!, and in that case the test can be uncommented and it passes. 
'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. We test that the email delivery count is increased by one when the email method is called.
 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:11:23Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this ''no tests have been written''.
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. We test that the email delivery count is increased by one when the email method is called.
 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:10:49Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so the test that has been written is commented out''. This test can be used if find_by is replaced with where!, and in that case it passes. The questionnaire function was not changed however since that is outside the scope of our project.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this ''no tests have been written''.
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. We test that the email delivery count is increased by one when the email method is called.
 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:10:31Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so the test that has been written is commented out''. This test can be used if find_by is replaced with where!, and in that case it passes. The questionnaire function was not changed however since that is outside the scope of our project.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this ''no tests have been written''.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. We test that the email delivery count is increased by one when the email method is called.
 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:09:32Z

Qdibble: /* email */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so the test that has been written is commented out''. This test can be used if find_by is replaced with where!, and in that case it passes. The questionnaire function was not changed however since that is outside the scope of our project.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this ''no tests have been written''.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate. We test that the email delivery count is increased by one when the email method is called.
 
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:07:21Z

Qdibble: /* teammate_response_report */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so the test that has been written is commented out''. This test can be used if find_by is replaced with where!, and in that case it passes. The questionnaire function was not changed however since that is outside the scope of our project.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this ''no tests have been written''.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID. We test that the function returns the corresponding teammate response report given a reviewer ID. 
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:06:25Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so the test that has been written is commented out''. This test can be used if find_by is replaced with where!, and in that case it passes. The questionnaire function was not changed however since that is outside the scope of our project.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>
'''commented test: questionnaire''' (for use when questionnaire is fixed)
<pre>
# describe '#questionnaire' do
# # This method is little more than a wrapper for assignment.review_questionnaire_id()
#
# context 'when corresponding active record for assignment_questionnaire is found' do
# before(:each) do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment.id).and_return(
# [assignment_teammate_questionnaire1, assignment_teammate_questionnaire2])
# allow(Questionnaire).to receive(:find).with(1).and_return(assignment_teammate_questionnaire1)
# end
#
# it 'returns correct questionnaire found by used_in_round and topic_id if both used_in_round and topic_id are given' do
# allow(AssignmentQuestionnaire).to receive(:where).with(assignment_id: assignment1.id, used_in_round: 1, topic_id: 1).and_return(
# [assignment_teammate_questionnaire1])
# allow(Questionnaire).to receive(:find_by!).with(type: 'TeammateReviewQuestionnaire').and_return([teammate_questionnaire1])
# #allow(Questionnaire).to receive(:where!).and_return([teammate_questionnaire1])
# assignment1.questionnaires = [teammate_questionnaire1, teammate_questionnaire2]
# expect(teammate_review_response_map1.questionnaire()).to eq(teammate_questionnaire1)
# end
#
# end
# end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this ''no tests have been written''.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:04:03Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this ''no tests have been written''.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:03:40Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it. The implementation of this method is inconsistent with the implementation of the questionnaire method in other classes, and uses find_by which always returns nil; because of this we have not tested it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:02:26Z

Qdibble: /* email */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:01:58Z

Qdibble: /* import */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?) is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T02:01:24Z

Qdibble: /* import */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. The last error check of the function ("No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}.") is impossible to reach in the function. This is because if the conditions to raise this error are met, a prior line in the code would have raised an error and exited first. Because this line is impossible to reach, it is impossible to test and the testing for it is commented out. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:59:03Z

Qdibble: /* import */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]
'''function: import'''
<pre>
def self.import(row_hash, session, id)
raise ArgumentError.new("Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>") if row_hash.length < 3
row_hash[:metareviewers].each do |row|
# ACS Make All contributors as teams
contributor = AssignmentTeam.where(name: row_hash[:reviewee].to_s, parent_id: id).first
raise ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found." if contributor.nil?
ruser = User.find_by_name(row_hash[:reviewer].to_s.strip)
reviewee = AssignmentParticipant.where(user_id: ruser.id, parent_id: id).first
raise ImportError, "Reviewee, #{row_hash[:reviewer].to_s}, for contributor, #{contributor.name}, was not found." if reviewee.nil?
muser = User.find_by_name(row.to_s.strip)
puts muser.name
reviewer = AssignmentParticipant.where(user_id: muser.id, parent_id: id)
raise ImportError, "Metareviewer, #{row.to_s}, for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s }, was not found." if reviewer.nil?
# ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
reviewmapping = ReviewResponseMap.where(reviewee_id: contributor.id, reviewer_id: reviewee.id)
# puts reviewee.id
puts reviewer.id
raise ImportError, "No review mapping was found for contributor, #{contributor.name}, and reviewee, #{row_hash[:reviewer].to_s}." if reviewmapping.nil?
existing_mappings = MetareviewResponseMap.where(reviewee_id: reviewee.id, reviewer_id: reviewer.id, reviewed_object_id: reviewmapping.map_id)
# if no mappings have already been imported for this combination
# create it.
MetareviewResponseMap.create(reviewer_id: reviewer.id, reviewee_id: reviewee.id, reviewed_object_id: reviewmapping.map_id) if existing_mappings.empty?
end
end
</pre>
'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:58:07Z

Qdibble: /* import */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
# # when a review response map is created
# allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
# allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
# allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
# allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
# allow(ReviewResponseMap).to receive(:find_or_create_by)
# .with(reviewed_object_id: 1, reviewer_id: 2, reviewee_id: 1, calibrate_to: false)
# .and_return(nil)
# expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "No review mapping was found for contributor, , and reviewee, #{row_hash[:reviewer].to_s}.")

end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:57:28Z

Qdibble: /* export_fields */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:57:16Z

Qdibble: /* exports */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:57:03Z

Qdibble: /* get_title */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:56:52Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''.

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:56:43Z

Qdibble: /* questionnaire */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned. Currently the implementation of this method makes it impossible to test, ''so no test has been written''

'''function: questionnaire'''
<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:53:35Z

Qdibble: /* assign_metareviewer */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review). 
'''function: assign_metareviewer'''
<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>
'''test: assign_metareviwer'''
<pre>
describe 'assign_metareviewer' do
context 'Assigns a metareviewer to a review' do
it 'creates a metareview response map' do
metareview_response_map_temp = create(:meta_review_response_map, reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id)
allow(MetareviewResponseMap).to receive(:create).with(reviewed_object_id: review_response_map1.id, reviewer_id: participant2.id, reviewee_id: participant1.id).and_return(\
metareview_response_map_temp)
expect(review_response_map1.assign_metareviewer(participant2)).to eq(metareview_response_map_temp)
end
end

end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:52:49Z

Qdibble: /* metareviewed_by? */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed 
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review).

<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:52:37Z

Qdibble: /* metareviewed_by? */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed
'''function: metareviewed_by?'''
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>
'''test: metareviewed_by?'''
<pre>
describe 'metareviewed_by?' do
context 'Returning whether it is metareviewed' do
it 'returns true' do
allow(MetareviewResponseMap).to receive(:where).with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: review_response_map.id).and_return([metareview_response_map])
expect(review_response_map.metareviewed_by?(participant1)).to eq(true)
end
end

end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review).

<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:51:54Z

Qdibble: /* self.reviewer_assessments_for(team, reviewer) */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 81.48% coverage

* teammate_review_response_map.rb <- 94.74% coverage

* response_map.rb <----------------- 96.45% coverage

This project aimed to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
This file was originally 92.5% covered, therefore no extra tests were written.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

'''function: get_all_versions'''
<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>
'''test: get_all_versions'''
<pre>
it 'finds version numbers' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_all_versions).to eq([])
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

'''function: contributor'''
<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>
'''test: contributor'''
<pre>
it 'finds the contributor of the metareview' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
allow(AssignmentTeam).to receive(:find).with(1).and_return(team)
expect(metareview_response_map.contributor).to eq(team)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

'''function: get_title'''
<pre>
def get_title
"Metareview"
end
</pre>

'''test: get_title'''
<pre>
it 'finds title' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(metareview_response_map.get_title).to eq("Metareview")
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file. 

'''function: export'''
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

'''test: export'''
<pre>
it '#export' do
csv = []
parent_id = 1
options = nil
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:find_by).and_return(metareview_response_map)
allow(Assignment).to receive(:find).and_return(assignment)
allow(Assignment).to receive(:metareview_mappings).and_return(metareview_response_map)
expect(MetareviewResponseMap.export(csv, parent_id, options)).to eq([metareview_response_map])
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned. 
'''function: export_fields'''
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>
'''test: export_fields'''
<pre>
it 'finds fields' do
allow(Response).to receive(:find).and_return(response)
allow(MetareviewResponseMap).to receive(:where).and_return([metareview_response_map])
expect(MetareviewResponseMap.export_fields(nil)).to eq(["contributor", "reviewed by", "metareviewed by"])
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview. 
[[File:E2170-import.jpg]]

'''test: import'''
<pre>
it '#import' do
row_hash = {reviewee: "name", metareviewers: ["name1"]}
session = nil
assignment_id = 1
# when reviewee user = nil
allow(User).to receive(:find_by).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ArgumentError, "Not enough items. The string should contain: Author, Reviewer, ReviewOfReviewer1 <, ..., ReviewerOfReviewerN>")
# when reviewee user doesn't exist
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name1"}
allow(User).to receive(:find_by).with(name: "name1").and_return(student)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: 1, parent_id: 1).and_return(nil)
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Contributor, " + row_hash[:reviewee].to_s + ", was not found.")
# when a metareview response map is created
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return([student])
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1).to eq(metareview_response_map) }
## when reviewer user doesn't exist
allow(User).to receive(:find_by).with(name: "name2").and_return(student2)
allow(AssignmentParticipant).to receive(:where).with(user_id: 3, parent_id: 1).and_return([participant])
allow(AssignmentTeam).to receive(:where).with(name: "name", parent_id: 1).and_return([team])
allow(AssignmentParticipant).to receive(:where).with(user_id: 1, parent_id: 1).and_return(nil)
row_hash = {reviewee: "name", metareviewers: ["name1"], reviewer: "name2"}
expect { MetareviewResponseMap.import(row_hash, session, 1) }.to raise_error(ImportError, "Metareviewer, name1, for contributor, team no name, and reviewee, name2, was not found.")
end
</pre>

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant. 
'''function: email'''
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: 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: "Metareview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { metareview_response_map.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

'''function: get title'''
<pre>
def get_title
"Teammate Review"
end
</pre>
'''test: get_title'''
<pre>
describe '#get_title' do
context 'when get_title is called' do
it '#get_title' do
expect(teammate_review_response_map1.get_title).to eq("Teammate Review")
end
end
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.
'''function: teammate_response_report'''
<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>
'''test: teammate_response_report'''
<pre>
describe '#teammate_response_report' do
context 'return an assignment given an id' do
it '#teammate_response_report' do
allow(TeammateReviewResponseMap).to receive_message_chain(:select, :where).and_return(assignment1);
expect(TeammateReviewResponseMap.teammate_response_report(2)).to eq(assignment1);
end
end
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.
'''function: email'''
<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>
'''test: email'''
<pre>
describe '#email' do
context 'when an email notification is sent' do
it '#email' do
reviewer_id = 1
allow(AssignmentParticipant).to receive(:find).with(2).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: "TeammateReview", obj_name: "Test Assgt", first_name: "no one", partial_name: "new_submission"}, to: "expertiza@mailinator.com"}
expect { teammate_review_response_map1.email(defn, participant, Assignment.find(Participant.find(reviewer_id).parent_id)) }
.to change { ActionMailer::Base.deliveries.count }.by 1
end
end
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
'''function: assessments_for'''
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>
'''test: assessments_for'''
<pre>
describe 'self.assessments_for' do
context 'Getting assessments for Review Response map' do
it 'returns only submitted responses' do
allow(Team).to receive(:find).and_return(team)
allow(ResponseMap).to receive(:where).with(reviewee_id: team.id).and_return([review_response_map, review_response_map1])
allow(Response).to receive(:where).with(map_id: 1).and_return([response])
allow(Response).to receive(:where).with(map_id: 2).and_return([response1])
responses = ResponseMap.assessments_for(team)
expect(responses).to eq([response])
end
end

context 'Getting assessments for other Response maps' do
it 'returns all responses' do
allow(Team).to receive(:find).and_return(team1)
allow(ResponseMap).to receive(:where).with(reviewee_id: participant2.id).and_return([teammate_review_response_map, teammate_review_response_map1])
allow(Response).to receive(:where).with(map_id: 3).and_return([response2])
allow(Response).to receive(:where).with(map_id: 4).and_return([response3])
responses = ResponseMap.assessments_for(participant2)
expect(responses).to eq([response2, response3])
end
end

end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.
'''function: reviewer_assessments_for'''
<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>
'''test: reviewer_assessments_for'''
<pre>
describe 'self.reviewer_assessments_for' do
context 'Returning latest version of responses by reviewer' do
it 'returns the second response' do
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response5)
end
it 'returns the response with the version number' do
response4.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
it 'returns the response with the highest version number' do
response4.version_num = 3
response5.version_num = 2
allow(ResponseMap).to receive(:where).with(reviewee_id: team2.id, reviewer_id: participant2.id ).and_return([review_response_map2])
allow(Response).to receive(:where).with(map_id: review_response_map2.id).and_return([response4, response5])
responses = ResponseMap.reviewer_assessments_for(team2, participant2)
expect(responses).to eq(response4)
end
end

end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review).

<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec spec/models/metareview_response_map_spec.rb spec/models/teammate_review_response_map_spec.rb spec/models/response_map_spec.rb spec/models/review_response_map_spec.rb
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:50:46Z

Qdibble: /* comparator */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:49:23Z

Qdibble: /* self.assessments_for(team) */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:47:46Z

Qdibble: /* email */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:47:00Z

Qdibble: /* teammate_response_report */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:45:41Z

Qdibble: /* get_title */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:43:46Z

Qdibble: /* email */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:43:03Z

Qdibble: /* import */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:41:02Z

Qdibble: /* export_fields */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:40:24Z

Qdibble: /* exports */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:37:29Z

Qdibble: /* get_title */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:36:13Z

Qdibble: /* contributor */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:35:40Z

Qdibble: /* metareview_response_map_spec.rb */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:33:38Z

Qdibble: /* get_all_versions */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:31:44Z

Qdibble: /* review_response_map_spec.rb */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:31:06Z

Qdibble: /* Description about project */