CSC/ECE 517 Fall 2018/E1852 Unit Test for Participant Model

From Expertiza_Wiki
Revision as of 21:10, 2 November 2018 by Rshakya (talk | contribs)
Jump to navigation Jump to search

Test Cases

TASKS IDENTIFIED

Test team

A Participant can be a member of a Team. When team method is called on a Participant, it should return the Team it belongs to.

describe "#team" do
  it "returns the team id for the user" do
    expect(participant.team).to eq(nil)
  end   
end

Test responses

   def responses
    response_maps.map(&:response)
   end


A Participant has many ResponseMaps that map a connection between this participant as a reviewer and as a reviewee. Each ResponseMap has many Responses associated with it. When responses method is called on a Participant, it should return an array of responses associated to this Participant.

 describe '#responses' do
     it 'returns an array of responses of the participant' do
       expect(participant.responses).to eql([])
     end
end

The above test will test a participant with no corresponding mapping. Hence the result of the responses provided by the participant is a nil list

Test name

 def name(ip_address = nil)
    self.user.name(ip_address)
end
 describe "#name" do
    it "returns the name of the user" do
      expect(participant.name).to eq "Student"
    end
end


A Participant is a User. When name method is called on a Participant, it should return the name of this User. Link title

Test fullname

  def fullname(ip_address = nil)
    self.user.fullname(ip_address)
end


A Participant is a User. When fullname method is called on a Participant, it should return the full name of this User.

Test handle

  def handle(ip_address = nil)
    User.anonymized_view?(ip_address) ? 'handle' : self[:handle]
end


Test delete

  def delete(force = nil)
    maps = ResponseMap.where('reviewee_id = ? or reviewer_id = ?', self.id, self.id)
    if force or (maps.blank? and self.team.nil?)
      force_delete(maps)
    else
      raise "Associations exist for this participant."
    end
end

Test force_delete

 
 def force_delete(maps)
    maps and maps.each(&:destroy)
    if self.team and self.team.teams_users.length == 1
      self.team.delete
    elsif self.team
      self.team.teams_users.each {|teams_user| teams_user.destroy if teams_user.user_id == self.id }
    end
    self.destroy
end

Test topic_name

 
 describe '#topic_name' do     
     context 'when the participant has an assignment without a topic' do
       it 'returns error message' do
         expect(participant.topic_name).to eql('<center>—</center>')
       end
end

Test able_to_review

 def able_to_review
   can_review
 end

When able_to_review method is called on a Participant, it should return true if it can review and false otherwise.

Test email

  def email(pw, home_page)
    user = User.find_by(id: self.user_id)
    assignment = Assignment.find_by(id: self.assignment_id)

    Mailer.sync_message(
      recipients: user.email,
      subject: "You have been registered as a participant in the Assignment #{assignment.name}",
      body: {
        home_page: home_page,
        first_name: ApplicationHelper.get_user_first_name(user),
        name: user.name,
        password: pw,
        partial_name: "register"
      }
    ).deliver
end

Test scores

def scores(questions)
    scores = {}
    scores[:participant] = self
    self.assignment.questionnaires.each do |questionnaire|
      round = AssignmentQuestionnaire.find_by(assignment_id: self.assignment.id, questionnaire_id: questionnaire.id).used_in_round
      questionnaire_symbol = if round
                               (questionnaire.symbol.to_s + round.to_s).to_sym
                             else
                               questionnaire.symbol
                             end
      scores[questionnaire_symbol] = {}
      scores[questionnaire_symbol][:assessments] = questionnaire.get_assessments_for(self)
      scores[questionnaire_symbol][:scores] = Answer.compute_scores(scores[questionnaire_symbol][:assessments], questions[questionnaire_symbol])
    end
    scores[:total_score] = assignment.compute_total_score(scores)
    scores
end

When scores method is called on a Participant, it should return the total scores it received for a given number of questions.

Test get_permissions

def self.get_permissions(authorization)
    can_submit = true
    can_review = true
    can_take_quiz = true
    case authorization
    when 'reader'
      can_submit = false
    when 'reviewer'
      can_submit = false
      can_take_quiz = false
    when 'submitter'
      can_review = false
      can_take_quiz = false
    end
    {can_submit: can_submit, can_review: can_review, can_take_quiz: can_take_quiz}
end


Test get_authorization

 def self.get_authorization(can_submit, can_review, can_take_quiz)
    authorization = 'participant'
    authorization = 'reader' if can_submit == false and can_review == true and can_take_quiz == true
    authorization = 'submitter' if can_submit == true and can_review == false and can_take_quiz == false
    authorization = 'reviewer' if can_submit == false and can_review == true and can_take_quiz == false
    authorization
end

Test sort_by_name

def self.sort_by_name(participants)
    users = []
    participants.each {|p| users << p.user }
    users.sort! {|a, b| a.name.downcase <=> b.name.downcase } # Sort the users based on the name
    participants.sort_by {|p| users.map(&:id).index(p.user_id) }
end

Participants are Users. When self.sort_by_name method is called on a Participant, it should sort a given set of participants based on their usernames.