E1848 Write unit tests for assignment team

For this progect, the goal is to wirte up unit tests for assignment_team.rb

Project Introduction

assignment_team.rb is the child class of team.rb. It is used to manage student teams in assignments. There are not enough unit tests for this model in expertiza. The following tests are added to assignment_team.rb in this project.

Unit Tests

Unit Test Tool

Rspec

Unit Test File

expertiza/spec/models/assignment_team_spec.rb

Unit Test Steps

• Create unit test cases in the assignment_team_spec.rb

• run rspec spec/models/assignment_team_spec.rb under expertiza directory

• the rspec outputs the number of test cases that are passed and those that are failed.

Unit Test Cases

Testing include?

2 test cases are designed to test this method:

1. The team includes a given participant.

      let(:assignment_team) { build(:assignment_team, id: 1, parent_id: 1, name: "full name") }
      let(:participant1) { build(:participant, id: 2, user: user) }
      it "returns true" do
        allow(assignment_team).to receive(:add_participants).with(participant1)
        expect(assignment_team.includes?(participant1))
      end

2. The team doesn't include a given participant.

      let(:assignment_team) { build(:assignment_team, id: 1, parent_id: 1, name: "full name") }
      let(:participant1) { build(:participant, id: 2, user: user) }
      let(:participant2) { build(:participant, id: 3) }
      it "returns false" do
        allow(assignment_team).to receive(:add_participants).with(participant1)
        expect(assignment_team.includes?(participant2))
      end

Testing parent_model

1 test case is designed to test this method:

      it "returns Assignment as result" do
        expect(assignment_team.parent_model).to eq("Assignment")
      end

Testing self.parent_model(id)

2 test cases are designed to test this method:

1.When it's given a correct id.

      let(:assignment) { build(:assignment, id: 1) }
      it "returns an assignemt" do
        allow(Assignment).to receive(:find).with(1).and_return(assignment)
        expect(AssignmentTeam.parent_model(1)).to eq(assignment)
      end

2.When it's given an incorrect id.

      it "raises an exception" do
        expect { AssignmentTeam.parent_model 2 }.to raise_exception(ActiveRecord::RecordNotFound)
      end

Testing fullname

1 test case is designed to test this method:

      it "returns the full name of assignment team" do
        expect(assignment_team.fullname).to eq("full name")
      end

Testing review_map_type

1 test case is designed to test this method:

      it "returns ReviewResponseMap as result" do
        expect(assignment_team.review_map_type).to eq("ReviewResponseMap")
      end

Testing self.prototype

1 test cases is designed to test this method:

      it "returns an new instance of AssignmentTeam" do
        expect(AssignmentTeam.prototype).to be_instance_of(AssignmentTeam)
      end

Testing assign_reviewer(reviewer)

2 test cases are designed to test this method:

1. When the team has an assignment.

      let(:reviewer) { build(:participant, id: 1) }
      it "returns an instance of ReviewResponseMap" do
        expect(assignment_team.assign_reviewer(reviewer)).to be_instance_of(ReviewResponseMap)
      end

2. When the assignment record can not be found"

      let(:assignment_team2) { build(:assignment_team, id: 2, parent_id: 2) }
      it "returns an exception" do
        expect { assignment_team2.assign_reviewer(reviewer) }.to raise_exception(ActiveRecord::RecordNotFound)
      end

Testing reviewd_by?

1 test case is designed to test this method:

      it "returns true" do
        allow(ReviewResponseMap).to receive(:where).\
          with('reviewee_id = ? && reviewer_id = ? && reviewed_object_id = ?', 1, 1, 1).and_return([review_response_map])
        expect(assignment_team.reviewed_by?(reviewer)).to be true
      end

Testing topic

1 test case is designed to test this method:

      let(:signed_up_team) { build(:signed_up_team, id: 1, team_id: 1, is_waitlisted: 0, topic_id: 1) }
      it "returns a topic id" do
        allow(SignedUpTeam).to receive(:find_by).with(team_id: 1, is_waitlisted: 0).and_return(signed_up_team)
        expect(assignment_team.topic).to eq(1)
      end

Testing has_submissions?

3 test cases are designed to test this method:

1.The team doesn't submit any file or link.

      let(:team2) { build(:assignment_team, id: 2, parent_id: 1, name: "team2", submitted_hyperlinks: "") }
      it "no file or no link" do
        expect(team2.has_submissions?).to eq(false)
      end

2.The team submits a link instead of files.

      let(:team1) { build(:assignment_team, id: 1, parent_id: 1, name: "team1", submitted_hyperlinks: "http://example.com") }
      it "submitted hyperlinks" do
        expect(team1.has_submissions?).to eq(true)
      end

3. The team submits some files. Stub is used to emulate the scenario that the team has submitted a file.

 
      it "returns true" do
        allow(team2).to receive(:submitted_files).and_return([double(:File)])
        expect(team2.has_submissions?).to be true
      end

Testing participants

1. No participants in this team

      it '#no participant' do
        expect(team1.participants).to eq([])
      end

2. add some participants and get all the participants

      let(:student1) { build(:student, id: 1, name: 'johns', fullname: 'johns franklin') }
      let(:student2) { build(:student, id: 2, name: 'kate', fullname: 'kate moss') }
      let(:par1) { build(:participant, id: 1, parent_id: 1, user_id: 1) }
      let(:par2) { build(:participant, id: 2, parent_id: 1, user_id: 2) }
      it '#1 participant' do
        allow(AssignmentTeam).to receive(:users).with(id: team1.id).and_return([student1,student2])
        expect(team1.participants).to eq([par1, par2])
      end

Testing add_participant

      it '#add participants' do
        expect(team1.add_participant(ass1.id, par1)).to be_instance_of(AssignmentParticipant)
      end

Testing the delete and destroy

      it '#delete' do
        expect(team1.delete).to be_instance_of(AssignmentTeam)
      end

      it '#destroy' do
        expect(team1.destroy).to be_instance_of(AssignmentTeam)
      end

Testing members

      it '#get_first_member' do
        allow(AssignmentTeam).to receive(:find_by).with(id: team1.id).and_return(team1)
        allow(team1).to receive(:participants).and_return([par1, par2])
        expect(AssignmentTeam.get_first_member(team1.id)).to eq(par1)
      end

Testing import and export

1. import a team to a non-existing assignment and expect an exception

     it '#import an nonexisting assignment id' do
        row = {teamname: "hello_world", teammembers: %w[johns kate]}
        options = {has_teamname: "true_first"}
        expect { AssignmentTeam.import(row, 99_999, options) }.to raise_error(ImportError)
      end

2. export teams into a csv file

      it '#export' do
        options = {}
        csv = CSV.open("assignment_team_export.csv", "w")
        assignment_id = ass1.id
        allow(AssignmentTeam).to receive(:where).with(parent_id: assignment_id).and_return([team1, team2, team3])
        allow(TeamsUser).to receive(:where).and_return([par1, par2])
        expect(AssignmentTeam.export(csv, assignment_id, options)).to be_instance_of(CSV)
      end

Testing copy

      it '#copy' do
        allow(TeamsUser).to receive(:where).with(team_id: team1.id).and_return([par1])
        expect(team1.copy(course1.id)).to eq([par1])
      end

Testing hyperlinks

2 test cases are designed to test this method:

1. when the current teams submitted hyperlinks

      let(:assignment_team) { build(:assignment_team) }
      context "when current teams submitted hyperlinks" do
        it "returns the hyperlinks submitted by the team" do
          expect(assignment_team.hyperlinks).to eq(["https://www.expertiza.ncsu.edu"])
        end
       end

2. when current teams did not submit hyperlinks

     let(:team_without_submitted_hyperlinks) { build(:assignment_team, submitted_hyperlinks: "") }
     context "when current teams did not submit hyperlinks" do
       it "returns an empty array" do
         expect(team_without_submitted_hyperlinks.hyperlinks).to eq([])
       end
      end