Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2018/E1876 Completion/Progress view

2018-11-14T01:56:03Z

Kaacken2: /* Files that will be changed */ Clean up the section.

='''Problem Statement'''=
A key component of Expertiza is peer reviews, which provide feedback to authors so that they can improve their work. Expertiza also supports grading of these reviews to ensure students write quality reviews, helping them learn more about the assignment by looking at their peers' work. In addition, Expertiza allows for metareviews, which are reviews the authors of the original work write for the reviews of their original work. This author feedback is useful for grading the reviews because it indicates how helpful this review was to the authors of the original work. The objective of this project is to add metareview or author feedback information to the review report page, which shows a summary of all the reviews written by the students for an assignment.

='''Goal'''=

The aim of this project is to build this into the system. We need an additional column in the 'Review Report' page for reviews which shows the calculation of the author feedback. This will help instructor's to know how the reviews proved useful to the authors/team. The aim of this project is to integrate the author feedback column in the summary page

='''Design'''=

== User Interface Enhancements ==

In the page "Review report for Design exercise" (Log in as an instructor then go to Manage -> Assignments -> View review report.), we are planning to add one more column to show the average ratings for the author feedback for a student's review of a particular assignment. The logic for calculating the average score for the metareviews would be similar to already implemented logic for the "Score Awarded/Average Score" column. Below is the page we are planning to edit.

[[File:Feedback_new.png]]

== Controller-level Logic ==

The following method shows the code logic we are planning to write for calculating the average scores for the feedback given by authors for the reviews of their work.

<pre style="color: black; border:1px;">
def calculate_avg_score_by_feedback(question_answers, q_max_score)
# get score and summary of answers for each question
# only include divide the valid_answer_sum with the number of valid answers

valid_answer_counter = 0
question_score = 0.0
question_answers.each do |ans|
# calculate score per question
unless ans.answer.nil?
question_score += ans.answer
valid_answer_counter += 1
end
end

if valid_answer_counter > 0 and q_max_score > 0
# convert the score in percentage
question_score /= (valid_answer_counter * q_max_score)
question_score = question_score.round(2) * 100
end

question_score
end

</pre>

== Relevant Database Tables ==

The following are the table structures we will need for this feature. First, the questions table has all the questions based on the questionnaire. We will be only concerned with the questions in the feedback questionnaire. The answers for each question in the feedback questionnaire are saved in the Answers table below based on the Question ID. Now, in order to know if the answer is a feedback by team members or a review by reviewer, the mapping for the Answers table is done by the response_id which is a foreign key to the Response table. This Response table gives us the map_id which maps to a response map table. Now, the response map table gives us information on the reviewer_id, reviewee_id, reviewed_object_id (which is the ID for the assignment being reviewed) and the type (whether it's a teammate review, author feedback, a regular review, etc.). We will have to fetch the answers from the Answer table based on response_id because in our case, the response is from a previous reviewee and not a reviewer. So, we will fetch those answers whose response type is FeedbackResponseMap and calculate scores for those questions for the corresponding ReviewScores table. Below are excerpts from the [http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables Expertiza database documentation] which describe the database tables relevant to our design.

=== Questions Table Structure ===


{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|unique identifier for the record
|-
!txt
|text
|the question string
|-
!weight
|int(11)
|specifies the weighting of the question
|-
!questionnaire_id
|int(11)
|the id of the questionnaire that this question belongs to
|-
!seq
|DECIMAL
|
|-
!type
|VARCHAR(255)
|Type of question
|-
!size
|VARCHAR(255)
|Size of the question
|-
!alternatives
|VARCHAR(255)
|Other question which means the same
|-
!break_before
|BIT
|
|-
!max_label
|VARCHAR(255)
|
|-
!min_label
|VARCHAR(255)
|
|}

=== Answer Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|Unique ID for each Answers record.
|-
!question_id
|int(11)
|ID of Question.
|-
!answer
|int(11)
|Value of each of the answer.
|-
!comments
|text
|Comment given to the answer.
|-
!reponse_id
|int(11)
|ID of the response associated with this Answer.
|}

=== Response Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!map_id
|int(11)
|The ID of the [[response_maps|response map]] defining the relationship that this response applies to
|-
!additional_comment
|text
|An additional comment provided by the reviewer to support his/her response
|-
!updated_at
|datetime
|The timestamp indicating when this response was last modified
|-
!created_at
|datetime
|The timestamp indicating when this response was created
|-
!version_num
|int(11)
|The version of the review.
|-
!round
|int(11)
|The round the review is connected to.
|-
!is_submitted
|tinyint(1)
|Boolean Field to indicate whether the review is submitted.
|}

=== Response Map Table ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!reviewed_object_id
|int(11)
|The object being reviewed in the [[responses|response]]. Possible objects include other ResponseMaps or [[assignments]]
|-
!reviewer_id
|int(11)
|The [[participants|participant]] (actually AssignmentParticipant) providing the response
|-
!reviewee_id
|int(11)
|The [[teams|team]] (AssignmentTeam) receiving the response
|-
!type
|varchar(255)
|Used for subclassing the response map. Available subclasses are ReviewResponseMap, MetareviewResponseMap, FeedbackResponseMap, TeammateReviewResponseMap
|-
!created_at
|DATETIME
|Date and Time for when the record was created
|-
!updated_at
|DATETIME
|Date and Time when the last update was made
|-
!calibrate_to
|BIT
|}

== Files That Will be Changed ==

1. To calculate the average author feedback score: https://github.com/jainmohit1/expertiza/blob/master/app/models/on_the_fly_calc.rb

2. To populate the average author feedback score for the view: https://github.com/jainmohit1/expertiza/blob/master/app/controllers/review_mapping_controller.rb

3. To add a field in the view: https://github.com/jainmohit1/expertiza/blob/master/app/views/review_mapping/response_report.html.haml

4. To add a field in the partial : https://github.com/jainmohit1/expertiza/blob/master/app/views/review_mapping/_review_report.html.erb

5. To add a field in the partial: https://github.com/jainmohit1/expertiza/blob/master/app/views/review_mapping/_team_score.html.erb

= Test Plan =
We plan to test the response report page (/review_mapping/response_report?id={:assignmentID}) to make sure the new field (average author feedback) exists.

Using [http://rspec.info/ RSpec] we will add a test case to review_mapping_controller_spec.rb.

<pre>
context 'when type is FeedbackResponseMap' do
context 'when assignment has author feedback feature' do
it 'renders response_report page with average author feedback data' do
allow(assignment).to receive(:varying_rubrics_by_round?).and_return(true)
allow(FeedbackResponseMap).to receive(:feedback_response_report).with('1', 'FeedbackResponseMap')
.and_return([participant, participant1], [1, 2], [3, 4], [])
params = {
id: 1,
report: {type: 'FeedbackResponseMap'},
}
get :response_report, params
expect(response).to render_template(:response_report)
expect(response).to have(:avg_author_feedback)
end
end
end
</pre>

We also plan to manually test the response report page to make sure the new field is aligning well in the UI in the expected place. We will attach the screenshot of the UI as the test result. We will test the cases of one and multiple reviews by a reviewer and verify the number and average scores of the metareviews for those reviews are rendered correctly.

= References =
1. http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables

2. https://github.com/jainmohit1/expertiza

3. https://github.com/expertiza/expertiza/pull/1290

CSC/ECE 517 Fall 2018/E1876 Completion/Progress view

2018-11-13T22:26:59Z

Kaacken2: /* Test Plan */ Add more material to and clean up the section.

='''Problem Statement'''=
A key component of Expertiza is peer reviews, which provide feedback to authors so that they can improve their work. Expertiza also supports grading of these reviews to ensure students write quality reviews, helping them learn more about the assignment by looking at their peers' work. In addition, Expertiza allows for metareviews, which are reviews the authors of the original work write for the reviews of their original work. This author feedback is useful for grading the reviews because it indicates how helpful this review was to the authors of the original work. The objective of this project is to add metareview or author feedback information to the review report page, which shows a summary of all the reviews written by the students for an assignment.

='''Goal'''=

The aim of this project is to build this into the system. We need an additional column in the 'Review Report' page for reviews which shows the calculation of the author feedback. This will help instructor's to know how the reviews proved useful to the authors/team. The aim of this project is to integrate the author feedback column in the summary page

='''Design'''=

== User Interface Enhancements ==

In the page "Review report for Design exercise" (Log in as an instructor then go to Manage -> Assignments -> View review report.), we are planning to add one more column to show the average ratings for the author feedback for a student's review of a particular assignment. The logic for calculating the average score for the metareviews would be similar to already implemented logic for the "Score Awarded/Average Score" column. Below is the page we are planning to edit.

[[File:Feedback_new.png]]

== Controller-level Logic ==

The following method shows the code logic we are planning to write for calculating the average scores for the feedback given by authors for the reviews of their work.

<pre style="color: black; border:1px;">
def calculate_avg_score_by_criterion(question_answers, q_max_score)
# get score and summary of answers for each question
# only include divide the valid_answer_sum with the number of valid answers

valid_answer_counter = 0
question_score = 0.0
question_answers.each do |ans|
# calculate score per question
unless ans.answer.nil?
question_score += ans.answer
valid_answer_counter += 1
end
end

if valid_answer_counter > 0 and q_max_score > 0
# convert the score in percentage
question_score /= (valid_answer_counter * q_max_score)
question_score = question_score.round(2) * 100
end

question_score
end

</pre>

== Relevant Database Tables ==

The following are the table structures we will need for this feature. First, the questions table has all the questions based on the questionnaire. We will be only concerned with the questions in the feedback questionnaire. The answers for each question in the feedback questionnaire are saved in the Answers table below based on the Question ID. Now, in order to know if the answer is a feedback by team members or a review by reviewer, the mapping for the Answers table is done by the response_id which is a foreign key to the Response table. This Response table gives us the map_id which maps to a response map table. Now, the response map table gives us information on the reviewer_id, reviewee_id, reviewed_object_id (which is the ID for the assignment being reviewed) and the type (whether it's a teammate review, author feedback, a regular review, etc.). We will have to fetch the answers from the Answer table based on response_id because in our case, the response is from a previous reviewee and not a reviewer. So, we will fetch those answers whose response type is FeedbackResponseMap and calculate scores for those questions for the corresponding ReviewScores table. Below are excerpts from the [http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables Expertiza database documentation] which describe the database tables relevant to our design.

=== Questions Table Structure ===


{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|unique identifier for the record
|-
!txt
|text
|the question string
|-
!weight
|int(11)
|specifies the weighting of the question
|-
!questionnaire_id
|int(11)
|the id of the questionnaire that this question belongs to
|-
!seq
|DECIMAL
|
|-
!type
|VARCHAR(255)
|Type of question
|-
!size
|VARCHAR(255)
|Size of the question
|-
!alternatives
|VARCHAR(255)
|Other question which means the same
|-
!break_before
|BIT
|
|-
!max_label
|VARCHAR(255)
|
|-
!min_label
|VARCHAR(255)
|
|}

=== Answer Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|Unique ID for each Answers record.
|-
!question_id
|int(11)
|ID of Question.
|-
!answer
|int(11)
|Value of each of the answer.
|-
!comments
|text
|Comment given to the answer.
|-
!reponse_id
|int(11)
|ID of the response associated with this Answer.
|}

=== Response Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!map_id
|int(11)
|The ID of the [[response_maps|response map]] defining the relationship that this response applies to
|-
!additional_comment
|text
|An additional comment provided by the reviewer to support his/her response
|-
!updated_at
|datetime
|The timestamp indicating when this response was last modified
|-
!created_at
|datetime
|The timestamp indicating when this response was created
|-
!version_num
|int(11)
|The version of the review.
|-
!round
|int(11)
|The round the review is connected to.
|-
!is_submitted
|tinyint(1)
|Boolean Field to indicate whether the review is submitted.
|}

=== Response Map Table ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!reviewed_object_id
|int(11)
|The object being reviewed in the [[responses|response]]. Possible objects include other ResponseMaps or [[assignments]]
|-
!reviewer_id
|int(11)
|The [[participants|participant]] (actually AssignmentParticipant) providing the response
|-
!reviewee_id
|int(11)
|The [[teams|team]] (AssignmentTeam) receiving the response
|-
!type
|varchar(255)
|Used for subclassing the response map. Available subclasses are ReviewResponseMap, MetareviewResponseMap, FeedbackResponseMap, TeammateReviewResponseMap
|-
!created_at
|DATETIME
|Date and Time for when the record was created
|-
!updated_at
|DATETIME
|Date and Time when the last update was made
|-
!calibrate_to
|BIT
|}

= Test Plan =
We plan to test the response report page (/review_mapping/response_report?id={:assignmentID}) to make sure the new field (average author feedback) exists.

Using [http://rspec.info/ RSpec] we will add a test case to review_mapping_controller_spec.rb.

<pre>
context 'when type is FeedbackResponseMap' do
context 'when assignment has author feedback feature' do
it 'renders response_report page with average author feedback data' do
allow(assignment).to receive(:varying_rubrics_by_round?).and_return(true)
allow(FeedbackResponseMap).to receive(:feedback_response_report).with('1', 'FeedbackResponseMap')
.and_return([participant, participant1], [1, 2], [3, 4], [])
params = {
id: 1,
report: {type: 'FeedbackResponseMap'},
}
get :response_report, params
expect(response).to render_template(:response_report)
expect(response).to have(:avg_author_feedback)
end
end
end
</pre>

We also plan to manually test the response report page to make sure the new field is aligning well in the UI in the expected place. We will attach the screenshot of the UI as the test result. We will test the cases of one and multiple reviews by a reviewer and verify the number and average scores of the metareviews for those reviews are rendered correctly.

= References =
1. http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables

2. https://github.com/jainmohit1/expertiza

CSC/ECE 517 Fall 2018/E1876 Completion/Progress view

2018-11-13T22:17:58Z

Kaacken2: /* References */

='''Problem Statement'''=
A key component of Expertiza is peer reviews, which provide feedback to authors so that they can improve their work. Expertiza also supports grading of these reviews to ensure students write quality reviews, helping them learn more about the assignment by looking at their peers' work. In addition, Expertiza allows for metareviews, which are reviews the authors of the original work write for the reviews of their original work. This author feedback is useful for grading the reviews because it indicates how helpful this review was to the authors of the original work. The objective of this project is to add metareview or author feedback information to the review report page, which shows a summary of all the reviews written by the students for an assignment.

='''Goal'''=

The aim of this project is to build this into the system. We need an additional column in the 'Review Report' page for reviews which shows the calculation of the author feedback. This will help instructor's to know how the reviews proved useful to the authors/team. The aim of this project is to integrate the author feedback column in the summary page

='''Design'''=

== User Interface Enhancements ==

In the page "Review report for Design exercise" (Log in as an instructor then go to Manage -> Assignments -> View review report.), we are planning to add one more column to show the average ratings for the author feedback for a student's review of a particular assignment. The logic for calculating the average score for the metareviews would be similar to already implemented logic for the "Score Awarded/Average Score" column. Below is the page we are planning to edit.

[[File:Feedback_new.png]]

== Controller-level Logic ==

The following method shows the code logic we are planning to write for calculating the average scores for the feedback given by authors for the reviews of their work.

<pre style="color: black; border:1px;">
def calculate_avg_score_by_criterion(question_answers, q_max_score)
# get score and summary of answers for each question
# only include divide the valid_answer_sum with the number of valid answers

valid_answer_counter = 0
question_score = 0.0
question_answers.each do |ans|
# calculate score per question
unless ans.answer.nil?
question_score += ans.answer
valid_answer_counter += 1
end
end

if valid_answer_counter > 0 and q_max_score > 0
# convert the score in percentage
question_score /= (valid_answer_counter * q_max_score)
question_score = question_score.round(2) * 100
end

question_score
end

</pre>

== Relevant Database Tables ==

The following are the table structures we will need for this feature. First, the questions table has all the questions based on the questionnaire. We will be only concerned with the questions in the feedback questionnaire. The answers for each question in the feedback questionnaire are saved in the Answers table below based on the Question ID. Now, in order to know if the answer is a feedback by team members or a review by reviewer, the mapping for the Answers table is done by the response_id which is a foreign key to the Response table. This Response table gives us the map_id which maps to a response map table. Now, the response map table gives us information on the reviewer_id, reviewee_id, reviewed_object_id (which is the ID for the assignment being reviewed) and the type (whether it's a teammate review, author feedback, a regular review, etc.). We will have to fetch the answers from the Answer table based on response_id because in our case, the response is from a previous reviewee and not a reviewer. So, we will fetch those answers whose response type is FeedbackResponseMap and calculate scores for those questions for the corresponding ReviewScores table. Below are excerpts from the [http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables Expertiza database documentation] which describe the database tables relevant to our design.

=== Questions Table Structure ===


{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|unique identifier for the record
|-
!txt
|text
|the question string
|-
!weight
|int(11)
|specifies the weighting of the question
|-
!questionnaire_id
|int(11)
|the id of the questionnaire that this question belongs to
|-
!seq
|DECIMAL
|
|-
!type
|VARCHAR(255)
|Type of question
|-
!size
|VARCHAR(255)
|Size of the question
|-
!alternatives
|VARCHAR(255)
|Other question which means the same
|-
!break_before
|BIT
|
|-
!max_label
|VARCHAR(255)
|
|-
!min_label
|VARCHAR(255)
|
|}

=== Answer Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|Unique ID for each Answers record.
|-
!question_id
|int(11)
|ID of Question.
|-
!answer
|int(11)
|Value of each of the answer.
|-
!comments
|text
|Comment given to the answer.
|-
!reponse_id
|int(11)
|ID of the response associated with this Answer.
|}

=== Response Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!map_id
|int(11)
|The ID of the [[response_maps|response map]] defining the relationship that this response applies to
|-
!additional_comment
|text
|An additional comment provided by the reviewer to support his/her response
|-
!updated_at
|datetime
|The timestamp indicating when this response was last modified
|-
!created_at
|datetime
|The timestamp indicating when this response was created
|-
!version_num
|int(11)
|The version of the review.
|-
!round
|int(11)
|The round the review is connected to.
|-
!is_submitted
|tinyint(1)
|Boolean Field to indicate whether the review is submitted.
|}

=== Response Map Table ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!reviewed_object_id
|int(11)
|The object being reviewed in the [[responses|response]]. Possible objects include other ResponseMaps or [[assignments]]
|-
!reviewer_id
|int(11)
|The [[participants|participant]] (actually AssignmentParticipant) providing the response
|-
!reviewee_id
|int(11)
|The [[teams|team]] (AssignmentTeam) receiving the response
|-
!type
|varchar(255)
|Used for subclassing the response map. Available subclasses are ReviewResponseMap, MetareviewResponseMap, FeedbackResponseMap, TeammateReviewResponseMap
|-
!created_at
|DATETIME
|Date and Time for when the record was created
|-
!updated_at
|DATETIME
|Date and Time when the last update was made
|-
!calibrate_to
|BIT
|}

= Test Plan =
* Plan to test the response report page (/review_mapping/response_report?id={:assignmentID}) to make sure the new field (avg author feedback) exists
** Using rspec we will add a test case to ReviewMappingControllerSpec.rb
<pre>

context 'when type is FeedbackResponseMap' do
context 'when assignment has author feedback feature' do
it 'renders response_report page with average author feedback data' do
allow(assignment).to receive(:varying_rubrics_by_round?).and_return(true)
allow(FeedbackResponseMap).to receive(:feedback_response_report).with('1', 'FeedbackResponseMap')
.and_return([participant, participant1], [1, 2], [3, 4], [])
params = {
id: 1,
report: {type: 'FeedbackResponseMap'},
}
get :response_report, params
expect(response).to render_template(:response_report)
expect(response).to have(:avg_author_feedback)
end
end
end
</pre>

* Also, we plan to manually test the response report page to make sure the new field is aligning well in the UI in the expected place. We will attach the screenshot of the UI as the test result.

= References =
1. http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables

2. https://github.com/jainmohit1/expertiza

CSC/ECE 517 Fall 2018/E1876 Completion/Progress view

2018-11-13T22:16:59Z

Kaacken2: /* Design */ Cleans up and reorders sections in the section.

='''Problem Statement'''=
A key component of Expertiza is peer reviews, which provide feedback to authors so that they can improve their work. Expertiza also supports grading of these reviews to ensure students write quality reviews, helping them learn more about the assignment by looking at their peers' work. In addition, Expertiza allows for metareviews, which are reviews the authors of the original work write for the reviews of their original work. This author feedback is useful for grading the reviews because it indicates how helpful this review was to the authors of the original work. The objective of this project is to add metareview or author feedback information to the review report page, which shows a summary of all the reviews written by the students for an assignment.

='''Goal'''=

The aim of this project is to build this into the system. We need an additional column in the 'Review Report' page for reviews which shows the calculation of the author feedback. This will help instructor's to know how the reviews proved useful to the authors/team. The aim of this project is to integrate the author feedback column in the summary page

='''Design'''=

== User Interface Enhancements ==

In the page "Review report for Design exercise" (Log in as an instructor then go to Manage -> Assignments -> View review report.), we are planning to add one more column to show the average ratings for the author feedback for a student's review of a particular assignment. The logic for calculating the average score for the metareviews would be similar to already implemented logic for the "Score Awarded/Average Score" column. Below is the page we are planning to edit.

[[File:Feedback_new.png]]

== Controller-level Logic ==

The following method shows the code logic we are planning to write for calculating the average scores for the feedback given by authors for the reviews of their work.

<pre style="color: black; border:1px;">
def calculate_avg_score_by_criterion(question_answers, q_max_score)
# get score and summary of answers for each question
# only include divide the valid_answer_sum with the number of valid answers

valid_answer_counter = 0
question_score = 0.0
question_answers.each do |ans|
# calculate score per question
unless ans.answer.nil?
question_score += ans.answer
valid_answer_counter += 1
end
end

if valid_answer_counter > 0 and q_max_score > 0
# convert the score in percentage
question_score /= (valid_answer_counter * q_max_score)
question_score = question_score.round(2) * 100
end

question_score
end

</pre>

== Relevant Database Tables ==

The following are the table structures we will need for this feature. First, the questions table has all the questions based on the questionnaire. We will be only concerned with the questions in the feedback questionnaire. The answers for each question in the feedback questionnaire are saved in the Answers table below based on the Question ID. Now, in order to know if the answer is a feedback by team members or a review by reviewer, the mapping for the Answers table is done by the response_id which is a foreign key to the Response table. This Response table gives us the map_id which maps to a response map table. Now, the response map table gives us information on the reviewer_id, reviewee_id, reviewed_object_id (which is the ID for the assignment being reviewed) and the type (whether it's a teammate review, author feedback, a regular review, etc.). We will have to fetch the answers from the Answer table based on response_id because in our case, the response is from a previous reviewee and not a reviewer. So, we will fetch those answers whose response type is FeedbackResponseMap and calculate scores for those questions for the corresponding ReviewScores table. Below are excerpts from the [http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables Expertiza database documentation] which describe the database tables relevant to our design.

=== Questions Table Structure ===


{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|unique identifier for the record
|-
!txt
|text
|the question string
|-
!weight
|int(11)
|specifies the weighting of the question
|-
!questionnaire_id
|int(11)
|the id of the questionnaire that this question belongs to
|-
!seq
|DECIMAL
|
|-
!type
|VARCHAR(255)
|Type of question
|-
!size
|VARCHAR(255)
|Size of the question
|-
!alternatives
|VARCHAR(255)
|Other question which means the same
|-
!break_before
|BIT
|
|-
!max_label
|VARCHAR(255)
|
|-
!min_label
|VARCHAR(255)
|
|}

=== Answer Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|Unique ID for each Answers record.
|-
!question_id
|int(11)
|ID of Question.
|-
!answer
|int(11)
|Value of each of the answer.
|-
!comments
|text
|Comment given to the answer.
|-
!reponse_id
|int(11)
|ID of the response associated with this Answer.
|}

=== Response Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!map_id
|int(11)
|The ID of the [[response_maps|response map]] defining the relationship that this response applies to
|-
!additional_comment
|text
|An additional comment provided by the reviewer to support his/her response
|-
!updated_at
|datetime
|The timestamp indicating when this response was last modified
|-
!created_at
|datetime
|The timestamp indicating when this response was created
|-
!version_num
|int(11)
|The version of the review.
|-
!round
|int(11)
|The round the review is connected to.
|-
!is_submitted
|tinyint(1)
|Boolean Field to indicate whether the review is submitted.
|}

=== Response Map Table ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!reviewed_object_id
|int(11)
|The object being reviewed in the [[responses|response]]. Possible objects include other ResponseMaps or [[assignments]]
|-
!reviewer_id
|int(11)
|The [[participants|participant]] (actually AssignmentParticipant) providing the response
|-
!reviewee_id
|int(11)
|The [[teams|team]] (AssignmentTeam) receiving the response
|-
!type
|varchar(255)
|Used for subclassing the response map. Available subclasses are ReviewResponseMap, MetareviewResponseMap, FeedbackResponseMap, TeammateReviewResponseMap
|-
!created_at
|DATETIME
|Date and Time for when the record was created
|-
!updated_at
|DATETIME
|Date and Time when the last update was made
|-
!calibrate_to
|BIT
|}

= Test Plan =
* Plan to test the response report page (/review_mapping/response_report?id={:assignmentID}) to make sure the new field (avg author feedback) exists
** Using rspec we will add a test case to ReviewMappingControllerSpec.rb
<pre>

context 'when type is FeedbackResponseMap' do
context 'when assignment has author feedback feature' do
it 'renders response_report page with average author feedback data' do
allow(assignment).to receive(:varying_rubrics_by_round?).and_return(true)
allow(FeedbackResponseMap).to receive(:feedback_response_report).with('1', 'FeedbackResponseMap')
.and_return([participant, participant1], [1, 2], [3, 4], [])
params = {
id: 1,
report: {type: 'FeedbackResponseMap'},
}
get :response_report, params
expect(response).to render_template(:response_report)
expect(response).to have(:avg_author_feedback)
end
end
end
</pre>

* Also, we plan to manually test the response report page to make sure the new field is aligning well in the UI in the expected place. We will attach the screenshot of the UI as the test result.

= References =
1) http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables

2) https://github.com/jainmohit1/expertiza

CSC/ECE 517 Fall 2018/E1876 Completion/Progress view

2018-11-13T22:04:10Z

Kaacken2: /* Problem Statement */ Overhauls the section

='''Problem Statement'''=
A key component of Expertiza is peer reviews, which provide feedback to authors so that they can improve their work. Expertiza also supports grading of these reviews to ensure students write quality reviews, helping them learn more about the assignment by looking at their peers' work. In addition, Expertiza allows for metareviews, which are reviews the authors of the original work write for the reviews of their original work. This author feedback is useful for grading the reviews because it indicates how helpful this review was to the authors of the original work. The objective of this project is to add metareview or author feedback information to the review report page, which shows a summary of all the reviews written by the students for an assignment.

='''Goal'''=

The aim of this project is to build this into the system. We need an additional column in the 'Review Report' page for reviews which shows the calculation of the author feedback. This will help instructor's to know how the reviews proved useful to the authors/team. The aim of this project is to integrate the author feedback column in the summary page

='''Design'''=

== Database ==

The following are the table structures we will need for mapping. First, the questions table has all the questions based on the questionnaire. We will be only concerned with the questions in the feedback questionnaire. The answers for each question in the feedback questionnaire is saved in Answers table below based on Question ID. Now, in order to know if the answers is a feedback by team members or a review by reviewer, the mapping for Answers table is done by response_id which is a foreign key to response table. Response table gives us map_id which maps to Response Maps table. Now, Response Map table gives us information of the reviewer_id, reviewee_id, reviewed_object_id (which is the id for the assignment being reviewed) and the type (whether it's a teammate review, author feedback or a regular review). We will have to fetch the answers from the Answer table based on response_id because in our case, the response is from a reviewee and not a reviewer. So, we will fetch those answers whose response type is FeedbackResponseMap and calculate scores for those questions from Review_Scores table.

=== Questions Table Structure===


{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|unique identifier for the record
|-
!txt
|text
|the question string
|-
!weight
|int(11)
|specifies the weighting of the question
|-
!questionnaire_id
|int(11)
|the id of the questionnaire that this question belongs to
|-
!seq
|DECIMAL
|
|-
!type
|VARCHAR(255)
|Type of question
|-
!size
|VARCHAR(255)
|Size of the question
|-
!alternatives
|VARCHAR(255)
|Other question which means the same
|-
!break_before
|BIT
|
|-
!max_label
|VARCHAR(255)
|
|-
!min_label
|VARCHAR(255)
|
|}

=== Answer Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|Unique ID for each Answers record.
|-
!question_id
|int(11)
|ID of Question.
|-
!answer
|int(11)
|Value of each of the answer.
|-
!comments
|text
|Comment given to the answer.
|-
!reponse_id
|int(11)
|ID of the response associated with this Answer.
|}

=== Response Table Structure ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!map_id
|int(11)
|The ID of the [[response_maps|response map]] defining the relationship that this response applies to
|-
!additional_comment
|text
|An additional comment provided by the reviewer to support his/her response
|-
!updated_at
|datetime
|The timestamp indicating when this response was last modified
|-
!created_at
|datetime
|The timestamp indicating when this response was created
|-
!version_num
|int(11)
|The version of the review.
|-
!round
|int(11)
|The round the review is connected to.
|-
!is_submitted
|tinyint(1)
|Boolean Field to indicate whether the review is submitted.
|}

=== Response Map Table ===

{| class="wikitable"
!Field Name !!Type !!Description
|-
!id
|int(11)
|The unique record id
|-
!reviewed_object_id
|int(11)
|The object being reviewed in the [[responses|response]]. Possible objects include other ResponseMaps or [[assignments]]
|-
!reviewer_id
|int(11)
|The [[participants|participant]] (actually AssignmentParticipant) providing the response
|-
!reviewee_id
|int(11)
|The [[teams|team]] (AssignmentTeam) receiving the response
|-
!type
|varchar(255)
|Used for subclassing the response map. Available subclasses are ReviewResponseMap, MetareviewResponseMap, FeedbackResponseMap, TeammateReviewResponseMap
|-
!created_at
|DATETIME
|Date and Time for when the record was created
|-
!updated_at
|DATETIME
|Date and Time when the last update was made
|-
!calibrate_to
|BIT
|}

== UI Implementation ==

In the page Review report for Design exercise ( login as an instructor -> Manage -> Assignments -> View review report ), we are planning to add one more column to show the average ratings for the authors feedback on a particular assignment. The logic for calculating the average score for the feedback would be similar to already implemented logic for score awarded/ average score column. Below attached shows the page we are planning to edit.

[[File:Feedback_new.png]]

== Code Logic ==

Following shows the code logic we are planning to write for calculating the avg scores for the feedback given by authors.
<pre style="color: black; border:1px;">
def calculate_avg_score_by_criterion(question_answers, q_max_score)
# get score and summary of answers for each question
# only include divide the valid_answer_sum with the number of valid answers

valid_answer_counter = 0
question_score = 0.0
question_answers.each do |ans|
# calculate score per question
unless ans.answer.nil?
question_score += ans.answer
valid_answer_counter += 1
end
end

if valid_answer_counter > 0 and q_max_score > 0
# convert the score in percentage
question_score /= (valid_answer_counter * q_max_score)
question_score = question_score.round(2) * 100
end

question_score
end

</pre>

= Test Plan =
* Plan to test the response report page (/review_mapping/response_report?id={:assignmentID}) to make sure the new field (avg author feedback) exists
** Using rspec we will add a test case to ReviewMappingControllerSpec.rb
<pre>

context 'when type is FeedbackResponseMap' do
context 'when assignment has author feedback feature' do
it 'renders response_report page with average author feedback data' do
allow(assignment).to receive(:varying_rubrics_by_round?).and_return(true)
allow(FeedbackResponseMap).to receive(:feedback_response_report).with('1', 'FeedbackResponseMap')
.and_return([participant, participant1], [1, 2], [3, 4], [])
params = {
id: 1,
report: {type: 'FeedbackResponseMap'},
}
get :response_report, params
expect(response).to render_template(:response_report)
expect(response).to have(:avg_author_feedback)
end
end
end
</pre>

* Also, we plan to manually test the response report page to make sure the new field is aligning well in the UI in the expected place. We will attach the screenshot of the UI as the test result.

= References =
1) http://wiki.expertiza.ncsu.edu/index.php/Documentation_on_Database_Tables

2) https://github.com/jainmohit1/expertiza

CSC/ECE 517 Fall 2018/E1876 Completion/Progress view

2018-11-13T14:28:09Z

Kaacken2: Adds initial section headers.

= Problem Statement =
= Design =
= Test Plan =
= References =

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T20:46:47Z

Kaacken2: /* Test Plan */ Add Courier font to method names in headings.

The purpose of this project is to improve the coverage and quality of the unit tests for the assignment team model in Expertiza. This project comprised the program 3 assignment of CSC/ECE 517 in fall 2018 and is entitled "Project E1848: Writing unit tests for assignment_team.rb." The source code for this project is in [https://github.com/expertiza/expertiza/pull/1228 pull request #1228] of the [https://github.com/expertiza Expertiza project] on [https://github.com/ GitHub].

== Key Contributions ==

Out of the 30 methods defined for the model AssignmentTeam.rb, test case was written for only one. Our contribution was to successfully add test cases for all remaining 29 methods.

Hence, increasing the coverage from 5% to 100%.

== The Class under Test ==
'''AssignmentTeam''' 
This class handles all functionalities for a team linked to an assignment. Some of the functionalities include, get a list of participants in the team, get the team name, team score for the given assignment, submissions for this team (files) and (hyperlinks) and topic picked by the team. Add/or remove participants from the team. It also checks for any reviews the team may have gotten for their work. Export all teams in a CSV file, import files from CSV to form teams.

== Test Plan ==
Our test plan was to test every method individually, i.e. write unit tests. We also tested multiple cases for each method. A description of all the methods in the '''AssignmentTeam''' model in assignment_team.rb and the RSpec unit tests we wrote for them is below.

=== The '''includes?(participant)''' Method ===
This function in assignment_team.rb checks if the '''participant''' passed as argument is a member of the team or not. For this, we utilize factorybot to build a user and a participant1 as follows-:
<pre>
let(:user1) { build(:student, id: 2) }
let(:participant1) { build(:participant, id: 1) }
</pre>

Test cases checked for are-: 
1) when the team receives a user, that user is allowed to become a team participant. The method returns '''True''' for the given participant passed as argument.

<pre>
context "when an assignment team has one participant" do
it "includes one participant" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
expect(team.includes?(participant1)).to eq true
end
end
</pre>

2) when the team receives a user with no arguments, that user is '''not''' allowed to become a team participant. The method returns '''False''' for the given participant passed as argument.

<pre>
context "when an assignment team has no users" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([])
expect(team.includes?(participant1)).to eq false
end
end
</pre>

=== The '''parent_model ''' Method ===
This function in assignment_team.rb always provides the name of the parent model which is '''Assignment'''.

Hence, the unit test also always checks if the response of this method is the string '''"Assignment"''' or not.
<pre>
it "provides the name of the parent model" do
expect(team.parent_model).to eq "Assignment"
end
</pre>

=== The '''self.parent_model(id) ''' Method ===
This function in assignment_team.rb takes in as argument id of the current '''Assignment''' for the team and returns an instance of the parent model.

Hence the unit test checks if the instance returned by this method for a given assignment id, matches the assignment or not.
<pre>
it "provides the instance of the parent model" do
allow(Assignment).to receive(:find).with(1).and_return(assignment)
expect(AssignmentTeam.parent_model(1)).to eq assignment
end
</pre>

=== The '''fullname ''' Method ===
This function in assignment_team.rb print out the name for the current class instance. for this we first build an assignment team instance and assign it the name '''"abcd"'''.

Hence the unit test checks if the assignment team has a name, and returns that same name.
<pre>
context "when the team has a name" do
it "provides the name of the class" do
team = build(:assignment_team, id: 1, name: "abcd")
expect(team.fullname).to eq "abcd"
end
end
</pre>

=== The '''review_map_type''' Method ===
This function in assignment_team.rb always provides the name of the review map type which is '''ReviewResponseMap'''.

Hence, the unit test also always checks if the response of this method is the string '''"ReviewResponseMap"''' or not.
<pre>
it "provides the review map type" do
expect(team.review_map_type).to eq "ReviewResponseMap"
end
</pre>

=== The '''self.prototype''' Method ===
This function in assignment_team.rb implements the prototype pattern by returning a new instance of the class '''AssignmentTeam'''.

The unit test checks if the response is a new instance of the class or not.
<pre>
it "provides the instance of the AssignmentTeam" do
expect(AssignmentTeam).to receive(:new).with(no_args)
AssignmentTeam.prototype
end
</pre>

=== The '''assign_reviewer(reviewer)''' Method ===
This function in assignment_team.rb assigns a reviewer to the team by returning a new instance of the class '''ReviewResponseMap'''.

The unit test assigns a reviewer to the team and creates an instance of ReviewResponseMap.
<pre>
describe "#assign_reviewer" do
context "when a reviewer is present" do
it "assign the reviewer to the team" do
allow(Assignment).to receive(:find).with(team.parent_id).and_return(assignment)
allow(ReviewResponseMap).to receive(:create).
with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: assignment.id).and_return(review_response_map)
expect(team.assign_reviewer(participant1)).to eq(review_response_map)
end
end
end
</pre>

=== The '''reviewed_by?(reviewer)''' Method ===
This function in assignment_team.rb checks if the team has been reviewed by a reviewer.

The unit test checks if the reviewer has reviewed the team. The test will find instances of ReviewResponseMaps belonging to the reviewer and the team, and will return true if such instances are present.

<pre>
describe "#reviewed_by?" do
context "when a team has a reviewer" do
it "has been reviewed by this reviewer" do
template = 'reviewee_id = ? && reviewer_id = ? && reviewed_object_id = ?'
allow(ReviewResponseMap).to receive(:where).with(template, team.id, participant1.id, team.assignment.id).and_return([review_response_map])
expect(team.reviewed_by?(participant1)).to eq true
end
end
</pre>

=== The '''topic''' Method ===
This function in assignment_team.rb return the id of the topic picked by the team for the assignment.

The unit test first stubs a topic for the given assignment, allows a SignedUpTeam object to receive that topic and AssignmentTeam id, and return the topic id to check if it matches with the topic id of the AssignmentTeam.
<pre>
context "when the team has picked a topic" do
it "provides the topic id" do
assignment = team.assignment
allow(SignUpTopic).to receive(:find_by).with(assignment: assignment).and_return(topic)
allow(SignedUpTeam).to receive_message_chain(:find_by, :try).with(team_id: team.id).with(:topic_id).and_return(topic.id)
expect(team.topic).to eq(topic.id)
end
end
</pre>

=== The '''has_submissions?''' Method ===
this function in assignment_team.rb is used to check if the team has submitted their work or not.

The unit test allows the team to receive submissions, by first receiving files as submission, then hyperlink as submission, and for each expects the the team's submission to be true when the function is called.
<pre>
context "when a team has submitted files" do
it "has submissions" do
allow(team).to receive_message_chain(:submitted_files, :any?).with(no_args).with(no_args).and_return(true)
end
end

context "when the team has submitted hyperlink" do
it "checks if the team has submissions" do
allow(team).to receive_message_chain(:submitted_hyperlinks, :present?).with(no_args).with(no_args).and_return(true)
end
end

after(:each) do
expect(team.has_submissions?).to be true
end
</pre>

=== The '''participants''' Method ===
This function in assignment_team.rb returns a list of all participants in the team.

The unit test first allows the team to receive two user instances and then adds these users as participants of the team. The test then expects the function to return a list of these two users as participants of the team.
<pre>
context "when an assignment team has two participants" do
it "has those two participants" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.participants).to eq [participant1, participant2]
end
end
</pre>

The unit test first allows the team to receive a user instance but does not add this user as participant of the team. The test then expects the function to return an empty list as participants of the team.
<pre>
context "when an assignment team has a user but no participants" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(nil)
expect(team.participants).to eq []
end
end
</pre>

=== The '''delete''' Method ===
This function in assignment_team.rb deletes the AssignmentTeam by destroying each participant in the team and returns an instance of AssignmentTeam.

The unit test first allows two users to be added as team participants. The test checks if the team deleted matches the current team instance.

<pre>
it "deletes the team" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.delete).to eq(team)
end
</pre>

=== The '''destroy''' Method ===
This function in assignment_team.rb deletes all the reviews associated with the team.

The unit test will delete every instance of '''ReviewResponseMaps''' associated with the team.
<pre>
describe "#destroy" do
it "delete the reviews" do
expect(team).to receive_message_chain(:review_response_maps, :each).with(no_args).with(no_args)
team.destroy
end
end
</pre>

=== The '''self.get_first_member(team_id)''' Method ===
This function in assignment_team.rb returns the instance of the first participant of the team for the given team id.

The unit test allows the assignment to receive a user, add it as a participant and return the first participant in the team. The test expects the function to return an instance of this participant.
<pre>
context "when team id is present" do
it "get first member of the team" do
allow(AssignmentTeam).to receive_message_chain(:find_by, :try, :try).with(id: team.id).with(:participant).with(:first).and_return(participant1)
expect(AssignmentTeam.get_first_member(team.id)).to eq(participant1)
end
end
</pre>

=== The '''submitted_files(path = self.path)''' Method ===
This function in assignment_team.rb returns a list of files belonging to a team for a given path.

The unit test checks if the response is equal to the list of files that the team has submitted.

<pre>
describe "#submitted_files" do
context "given a path" do
it "returns submitted files" do
files = ["file1.rb"]
path = "assignment_path/5"
allow(team).to receive(:path).with(path)
allow(team).to receive(:files).with(path).and_return(files)
expect(team.submitted_files(path)).to match_array(files)
end
end
end
</pre>

=== The '''self.import(row, assignment_id, options)''' Method ===
This function in assignment_team.rb imports a team if the team with the given id is present.

The unit test checks if the team is not imported if the team with the given id is not already present.

context "when an assignment team does not already exist with the same id" do
it "cannot be imported" do
assignment_id = 1
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(nil)
error_message = "The assignment with the id \"" + assignment_id.to_s + "\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
expect { AssignmentTeam.import([], assignment_id, []) }.
to raise_error(ImportError, error_message)
end
end

The unit test checks if the team is imported if the team with the given id is already present.

context "when an assignment team with the same id already exists" do
it "gets imported through Team.import" do
row = []
assignment_id = 1
options = []
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(assignment)
allow(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
expect(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
AssignmentTeam.import(row, assignment_id, options)
end
end

=== The '''self.export(csv, parent_id, options)''' Method ===
This function in assignment_team.rb exports an instance of class '''AssignmentTeam'''

The unit test checks if the response is a new instance of the class '''AssignmentTeam''' or not.

<pre>
describe ".export" do
it "redirects to Team.export with a new AssignmentTeam object" do
allow(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
expect(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
AssignmentTeam.export([], 1, [])
end
end
</pre>

=== The '''copy(course_id)''' Method ===
This function in assignment_team.rb copies the current assignment team and creates a new CourseTeam instance from the given team. It takes as parameter the id of the course assignment team has.

The test grabs the course id from the assignment team and calls the function to check if a course team is successfully created or not. The function returns and empty array, otherwise returns '''nil''' if the course team is not created successfully.
<pre>
context "for given assignment team" do
it "copies the assignment team to course team" do
assignment = team.assignment
course = assignment.course
expect(team.copy(course.id)).to eq([])
end
end
</pre>

=== The '''add_participant(assignment_id, user)''' Method ===
This function in assignment_team.rb adds the user to the AssignmentTeam for the given assignment.

The unit test creates a user, and passes the user, assignment id for the team to the function and expects the result to be an instance of '''AssignmentParticipant''' meaning the user was successfully added as a participant.
<pre>
context "when a user is not a part of the team" do
it "adds the user to the team" do
user = build(:student, id: 10)
assignment = team.assignment
expect(team.add_participant(assignment.id, user)).to be_an_instance_of(AssignmentParticipant)
end
end
</pre>
 
The unit test creates a user, adds him as a participant to the team, and passes the user, assignment id for the team to the function and expects the result to be '''nil''' as the user already exists as participant of the team.
<pre>
context "when a user is already a part of the team" do
it "returns without adding user to the team" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
assignment = team.assignment
expect(team.add_participant(assignment.id, user1)).to eq(nil)
end
end
</pre>

=== The '''scores(questions)''' Method ===
This function in assignment_team.rb returns the total score of the team. This function calculates scores for a given hash of questions.

The unit test checks if the response is equal to the score.

<pre>
describe "#scores" do
context "when a hash of question is given" do
it "returns the score received by the team" do
questionnaire1 = build(:questionnaire, id: 1)
questionnaire2 = build(:questionnaire, id: 2)

question1 = build(:question, id: 1, questionnaire: questionnaire1)
question2 = build(:question, id: 2, questionnaire: questionnaire2)
questions = {questionnaire1.symbol => [question1], questionnaire2.symbol => [question2]}

scores = {}
scores[:team] = team
scores[:questionnaire1] = {}
scores[:questionnaire1][:assessments] = review_response_map
scores[:questionnaire1][:scores] = 5
scores[:questionnaire2] = {}
scores[:questionnaire2][:assessments] = review_response_map
scores[:questionnaire2][:scores] = 5
scores[:total_score] = 10

allow(team.assignment).to receive(:questionnaires).with(no_args).and_return([questionnaire1, questionnaire2])
allow(ReviewResponseMap).to receive(:where).with(reviewee_id: team.id).and_return(review_response_map)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire1][:assessments], questions[:questionnaire1]).and_return(5)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire2][:assessments], questions[:questionnaire2]).and_return(5)
allow(questionnaire1).to receive(:symbol).with(no_args).and_return(:questionnaire1)
allow(questionnaire2).to receive(:symbol).with(no_args).and_return(:questionnaire2)
allow(team.assignment).to receive(:compute_total_score).with(scores.except(:total_score)).and_return(10)
expect(team.scores(questions)).to eq(scores)
end
end
end

</pre>

=== The '''files(directory)''' Method ===
This method in assignment_team.rb successfully returns a list of files in any given directory path, not just the assignment teams directory path.

The unit test assigns the directory path as given below and checks if the list of files returned contains a specific file which is known to be in the list.
<pre>
context "when file is present in the directory" do
it "provides the list of files in directory and checks if file is present" do
directory = "spec/models"
expect(team.files(directory)).to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

The unit test assigns the directory path as given below and checks if the list of files returned does not contain a specific file which is known to not be in the list.
<pre>
context "when file is not present in the directory" do
it "provides the list of files in directory and checks if file is not present" do
directory = "spec/controllers"
expect(team.files(directory)).not_to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

=== The '''submit_hyperlink(hyperlink)''' Method ===
This function in assignment_team.rb submits the hyperlink for the team if it is valid or not empty.

The unit test checks if the hyperlink is empty and raises an error.
<pre>
context "when a hyperlink is empty" do
it "causes an exception to be raised" do
expect { team.submit_hyperlink("") }.to raise_error("The hyperlink cannot be empty!")
end
end
</pre>

The unit test checks if the hyperlink is invalid and raises a 404 error.
<pre>
context "when a hyperlink is invalid" do
it "causes an exception to be raised with the proper HTTP status code" do
invalid_hyperlink = "https://expertiza.ncsu.edu/not_a_valid_path"
allow(Net::HTTP).to receive(:get_response).and_return("404")
expect { team.submit_hyperlink(invalid_hyperlink) }.to raise_error("HTTP status code: 404")
end
end
</pre>

The unit test checks if the the hyperlink has been submitted or not.
context "when a valid hyperlink not in a certain improper format is submitted" do
it "it is fixed and is saved to the database" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu"])
allow(team).to receive(:submitted_hyperlinks=)
allow(team).to receive(:save)
allow(Net::HTTP).to receive(:get_response).and_return("0")
allow(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "http://www.ncsu.edu"])
team.submit_hyperlink("www.ncsu.edu ")
end
end
end
</pre>

=== The '''remove_hyperlink(hyperlink_to_delete)''' Method ===
This function in assignment_team.rb removes the hyperlink submitted by the team.

The unit test checks if the hyperlink has been deleted or not.
describe "#remove_hyperlink" do
context "when the hyperlink is in the assignment team's hyperlinks" do
it "is removed from the team's list of hyperlinks" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu", "https://www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu"])
team.remove_hyperlink("https://www.ncsu.edu")
end
end
end

=== The '''self.team(participant)''' Method ===
This function in assignment_team.rb returns the AssingmentTeam object that the given participant belongs to.

The unit test first builds a user and assigns that user as a participant1 of the team. Then allows that participant to be added as a team user and finally search the team for the given team user and expect the team for participant1 to be equal to the AssignmentTeam.
<pre>
context "when there is a participant" do
it "provides the team for participant" do
teamuser = build(:team_user, id: 1, team_id: team.id, user_id: user1.id)
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(TeamsUser).to receive(:where).with(user_id: participant1.user_id).and_return([teamuser])
allow(Team).to receive(:find).with(teamuser.team_id).and_return(team)
expect(AssignmentTeam.team(participant1)).to eq(team)
end
end
</pre>

=== The '''self.export_fields(options)''' Method ===
This function in assignment_team.rb exports the fields for a given set of options. It always returns a list containing ["Team Name", "Assignment Name"] if the given set of options have a team name set to true.

The unit test expects the method to return a static list of strings for the team passed as options, with the team having a name.
<pre>
context "when team has name" do
it "exports the fields" do
expect(AssignmentTeam.export_fields(team)).to eq(["Team Name", "Assignment Name"])
end
end
</pre>

=== The '''self.remove_team_by_id(id)''' Method ===
This function in assignment_team.rb removes team by using its id.

The unit test deletes the team by using its id and checks if return value is the instance of class '''AssignmentTeam'''.

<pre>
describe ".remove_team_by_id" do
context "when a team has an id" do
it "delete the team by id" do
allow(AssignmentTeam).to receive(:find).with(team.id).and_return(team)
expect(AssignmentTeam.remove_team_by_id(team.id)).to eq(team)
end
end
end
</pre>

=== The '''path''' Method ===
This function in assignment_team.rb returns a path to the directory where the team has submitted their files.

The unit test checks if the response is equal to the path belonging to the team's submission.
<pre>
describe "#path" do
it "returns the path" do
allow(team).to receive_message_chain(:assignment, :path).and_return("assignment_path")
allow(team).to receive(:directory_num).and_return(5)
expect(team.path).to eq "assignment_path/5"
end
end
</pre>

=== The '''set_student_directory_num''' Method ===
This function in assignment_team.rb sets the directory number for the team.

The unit test checks if the directory number for the team has been set. The test will check if the return value is equal to true.

<pre>
describe "#set_student_directory_num" do
it "sets the directory for the team" do
team = build(:assignment_team, id: 1, parent_id: 1, directory_num: -1)
max_num = 0
allow(AssignmentTeam).to receive_message_chain(:where, :order, :first, :directory_num).
with(parent_id: team.parent_id).with(:directory_num, :desc).with(no_args).with(no_args).and_return(max_num)
expect(team.set_student_directory_num).to be true
end
end
</pre>

=== The '''received_any_peer_review?''' Method ===
This function in assignment_team.rb checks if the team has received any peer reviews.

The unit test checks if any instance of '''ReviewResponseMap''' is present for the team.

<pre>
describe "#received_any_peer_review?" do
it "checks if the team has received any reviews" do
allow(ResponseMap).to receive_message_chain(:where, :any?).with(reviewee_id: team.id, reviewed_object_id: team.parent_id).with(no_args).and_return(true)
expect(team.received_any_peer_review?).to be true
end
end
</pre>

== Test Design ==
We used multiple RSpec-specific and general industry best practices for testing in our unit tests. A description of our use of some of these techniques follows.

=== Test Structure ===
We exploited '''describe''' blocks in RSpec to give our unit tests a readable structure. We had '''describe''' blocks for each method of '''AssignmentTeam'''. In these blocks, we used RSpec '''context''' blocks where appropriate and examples to identify and test the different cases in the source code.

=== Stubs for Isolating the UUT ===
In order to isolate the unit under test (UUT), i.e. the current method under test, we employed RSpec stubs. We stubbed out database calls and methods that triggered them in order to improve the run time of the unit tests, and we also stubbed out some outgoing command and query messages in order to test only the current method under test.

=== DRY Testing Practices ===
We exploited factories and the RSpec helper method '''let''' to make our unit tests shorter, more readable, and more maintainable, or, in essence, DRYer. Using the FactoryBot factories in '''factories.rb''' allowed us to use real Expertiza objects in our unit tests. We used the '''FactoryBot.build''' method to make our objects in order to avoid the run time penalty of saving (and this later having to retrieve) objects from the database. We used the '''let''' method with the factory as in the example below to make lazy-allocated objects which are cached throughout each example, improving run time.

<pre>let(:team) { build(:assignment_team, id: 1, parent_id: 1) }</pre>

Whenever '''team''' is called in an example, it returns the same value, i.e. the same object, which essentially allows tests that need it to have access to the same object without the need for allocating it as a class variable or instance variable for all of the tests or some of the tests. We placed these statements outside the scope of our unit test examples so the same objects could be used throughout all of them, DRYing out the test code.

== Testing Framework ==

=== RSpec Introduction ===
[http://rspec.info/ RSPEC] is a testing framework for Ruby for behavior-driven development (BDD) licensed under MIT. It is inspired by JBehave and contains fully integrated JMock based framework which has a very rich and powerful DSL (domain-specific language) which resembles a natural language specification. Composed of multiple libraries structured to work together, RSpec provides encapsulated testing via the describe block to specify the behavior of the class and the context for the unit test case.

=== Why RSpec? ===
RSpec is easy to learn and implement and can be used with other testing tools like Cucumber and Minitest independently. It is extremely powerful for testing states with complicated setup and also helps in tearing down complex code to access the objects required for testing RSpec semantics encourage agile thinking and practice and it structures the tests in a more intuitive way.

== Bugs Fixed ==
During testing of the '''AssignmentTeam''' model, we found two bugs, one in '''AssignmentTeam#submit_hyperlink''' and one in '''AssignmentTeam.import'''. In '''AssignmentTeam#submit_hyperlink''', '''http://''' was ''appended'' to hyperlink strings without this tag or
'''https://''' at the start of them, rather than ''prepended''. We fixed this error in our pull request. In '''AssignmentTeam.import''', '''id''', an undefined parameter, was referenced while raising an exception, and we updated it to '''assignment_id''', which was the actual name of the parameter passed to the method.

== Results ==
The model has a total of 237 lines, out of which 127 were relevant lines.
We achieved 100% coverage with avg hits per line at 2.3 (the number of times each specific line was run during the test suite)

[[File:Coverage_header.png]]
[[File:Coverage_line.png]]

== Future Work ==

DRY principle could be cleaned up a little more. Sometimes it became necessary to use the '''let''' or '''build''' helper methods in each unit test. They may all be consolidated at the beginning. 
Some more edge cases could be thought of for each method, and tests written for those. Although, we have tried to cover as many as possible. 
Additionally, in the future, the code may also be refactored with a more efficient tool. 
Test coverage through quality tests consistently added throughout the development of the Expertiza project should be the future work of the project. 

== References ==
1. [http://expertiza.ncsu.edu Expertiza] 
2. [http://wiki.expertiza.ncsu.edu/index.php/Main_Page#Expertiza Expertiza Wikipedia ] 
3. [https://github.com/expertiza/expertiza Expertiza Github Repository] 
4. [https://relishapp.com/rspec RSpec - Relish] 
5. [https://sites.google.com/site/longlastingsoftware Engineering Software as a Service]

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T20:44:09Z

Kaacken2: /* Test Plan */ Edit headings.

The purpose of this project is to improve the coverage and quality of the unit tests for the assignment team model in Expertiza. This project comprised the program 3 assignment of CSC/ECE 517 in fall 2018 and is entitled "Project E1848: Writing unit tests for assignment_team.rb." The source code for this project is in [https://github.com/expertiza/expertiza/pull/1228 pull request #1228] of the [https://github.com/expertiza Expertiza project] on [https://github.com/ GitHub].

== Key Contributions ==

Out of the 30 methods defined for the model AssignmentTeam.rb, test case was written for only one. Our contribution was to successfully add test cases for all remaining 29 methods.

Hence, increasing the coverage from 5% to 100%.

== The Class under Test ==
'''AssignmentTeam''' 
This class handles all functionalities for a team linked to an assignment. Some of the functionalities include, get a list of participants in the team, get the team name, team score for the given assignment, submissions for this team (files) and (hyperlinks) and topic picked by the team. Add/or remove participants from the team. It also checks for any reviews the team may have gotten for their work. Export all teams in a CSV file, import files from CSV to form teams.

== Test Plan ==
Our test plan was to test every method individually, i.e. write unit tests. We also tested multiple cases for each method. A description of all the methods in the '''AssignmentTeam''' model in assignment_team.rb and the RSpec unit tests we wrote for them is below.

=== The includes?(participant) Method ===
This function in assignment_team.rb checks if the '''participant''' passed as argument is a member of the team or not. For this, we utilize factorybot to build a user and a participant1 as follows-:
<pre>
let(:user1) { build(:student, id: 2) }
let(:participant1) { build(:participant, id: 1) }
</pre>

Test cases checked for are-: 
1) when the team receives a user, that user is allowed to become a team participant. The method returns '''True''' for the given participant passed as argument.

<pre>
context "when an assignment team has one participant" do
it "includes one participant" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
expect(team.includes?(participant1)).to eq true
end
end
</pre>

2) when the team receives a user with no arguments, that user is '''not''' allowed to become a team participant. The method returns '''False''' for the given participant passed as argument.

<pre>
context "when an assignment team has no users" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([])
expect(team.includes?(participant1)).to eq false
end
end
</pre>

=== The parent_model Method ===
This function in assignment_team.rb always provides the name of the parent model which is '''Assignment'''.

Hence, the unit test also always checks if the response of this method is the string '''"Assignment"''' or not.
<pre>
it "provides the name of the parent model" do
expect(team.parent_model).to eq "Assignment"
end
</pre>

=== The self.parent_model(id) Method ===
This function in assignment_team.rb takes in as argument id of the current '''Assignment''' for the team and returns an instance of the parent model.

Hence the unit test checks if the instance returned by this method for a given assignment id, matches the assignment or not.
<pre>
it "provides the instance of the parent model" do
allow(Assignment).to receive(:find).with(1).and_return(assignment)
expect(AssignmentTeam.parent_model(1)).to eq assignment
end
</pre>

=== The fullname Method ===
This function in assignment_team.rb print out the name for the current class instance. for this we first build an assignment team instance and assign it the name '''"abcd"'''.

Hence the unit test checks if the assignment team has a name, and returns that same name.
<pre>
context "when the team has a name" do
it "provides the name of the class" do
team = build(:assignment_team, id: 1, name: "abcd")
expect(team.fullname).to eq "abcd"
end
end
</pre>

=== The review_map_type Method ===
This function in assignment_team.rb always provides the name of the review map type which is '''ReviewResponseMap'''.

Hence, the unit test also always checks if the response of this method is the string '''"ReviewResponseMap"''' or not.
<pre>
it "provides the review map type" do
expect(team.review_map_type).to eq "ReviewResponseMap"
end
</pre>

=== The self.prototype Method ===
This function in assignment_team.rb implements the prototype pattern by returning a new instance of the class '''AssignmentTeam'''.

The unit test checks if the response is a new instance of the class or not.
<pre>
it "provides the instance of the AssignmentTeam" do
expect(AssignmentTeam).to receive(:new).with(no_args)
AssignmentTeam.prototype
end
</pre>

=== The assign_reviewer(reviewer) Method ===
This function in assignment_team.rb assigns a reviewer to the team by returning a new instance of the class '''ReviewResponseMap'''.

The unit test assigns a reviewer to the team and creates an instance of ReviewResponseMap.
<pre>
describe "#assign_reviewer" do
context "when a reviewer is present" do
it "assign the reviewer to the team" do
allow(Assignment).to receive(:find).with(team.parent_id).and_return(assignment)
allow(ReviewResponseMap).to receive(:create).
with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: assignment.id).and_return(review_response_map)
expect(team.assign_reviewer(participant1)).to eq(review_response_map)
end
end
end
</pre>

=== The reviewed_by?(reviewer) Method ===
This function in assignment_team.rb checks if the team has been reviewed by a reviewer.

The unit test checks if the reviewer has reviewed the team. The test will find instances of ReviewResponseMaps belonging to the reviewer and the team, and will return true if such instances are present.

<pre>
describe "#reviewed_by?" do
context "when a team has a reviewer" do
it "has been reviewed by this reviewer" do
template = 'reviewee_id = ? && reviewer_id = ? && reviewed_object_id = ?'
allow(ReviewResponseMap).to receive(:where).with(template, team.id, participant1.id, team.assignment.id).and_return([review_response_map])
expect(team.reviewed_by?(participant1)).to eq true
end
end
</pre>

=== The topic Method ===
This function in assignment_team.rb return the id of the topic picked by the team for the assignment.

The unit test first stubs a topic for the given assignment, allows a SignedUpTeam object to receive that topic and AssignmentTeam id, and return the topic id to check if it matches with the topic id of the AssignmentTeam.
<pre>
context "when the team has picked a topic" do
it "provides the topic id" do
assignment = team.assignment
allow(SignUpTopic).to receive(:find_by).with(assignment: assignment).and_return(topic)
allow(SignedUpTeam).to receive_message_chain(:find_by, :try).with(team_id: team.id).with(:topic_id).and_return(topic.id)
expect(team.topic).to eq(topic.id)
end
end
</pre>

=== The has_submissions? Method ===
this function in assignment_team.rb is used to check if the team has submitted their work or not.

The unit test allows the team to receive submissions, by first receiving files as submission, then hyperlink as submission, and for each expects the the team's submission to be true when the function is called.
<pre>
context "when a team has submitted files" do
it "has submissions" do
allow(team).to receive_message_chain(:submitted_files, :any?).with(no_args).with(no_args).and_return(true)
end
end

context "when the team has submitted hyperlink" do
it "checks if the team has submissions" do
allow(team).to receive_message_chain(:submitted_hyperlinks, :present?).with(no_args).with(no_args).and_return(true)
end
end

after(:each) do
expect(team.has_submissions?).to be true
end
</pre>

=== The participants Method ===
This function in assignment_team.rb returns a list of all participants in the team.

The unit test first allows the team to receive two user instances and then adds these users as participants of the team. The test then expects the function to return a list of these two users as participants of the team.
<pre>
context "when an assignment team has two participants" do
it "has those two participants" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.participants).to eq [participant1, participant2]
end
end
</pre>

The unit test first allows the team to receive a user instance but does not add this user as participant of the team. The test then expects the function to return an empty list as participants of the team.
<pre>
context "when an assignment team has a user but no participants" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(nil)
expect(team.participants).to eq []
end
end
</pre>

=== The delete Method ===
This function in assignment_team.rb deletes the AssignmentTeam by destroying each participant in the team and returns an instance of AssignmentTeam.

The unit test first allows two users to be added as team participants. The test checks if the team deleted matches the current team instance.

<pre>
it "deletes the team" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.delete).to eq(team)
end
</pre>

=== The destroy Method ===
This function in assignment_team.rb deletes all the reviews associated with the team.

The unit test will delete every instance of '''ReviewResponseMaps''' associated with the team.
<pre>
describe "#destroy" do
it "delete the reviews" do
expect(team).to receive_message_chain(:review_response_maps, :each).with(no_args).with(no_args)
team.destroy
end
end
</pre>

=== The self.get_first_member(team_id) Method ===
This function in assignment_team.rb returns the instance of the first participant of the team for the given team id.

The unit test allows the assignment to receive a user, add it as a participant and return the first participant in the team. The test expects the function to return an instance of this participant.
<pre>
context "when team id is present" do
it "get first member of the team" do
allow(AssignmentTeam).to receive_message_chain(:find_by, :try, :try).with(id: team.id).with(:participant).with(:first).and_return(participant1)
expect(AssignmentTeam.get_first_member(team.id)).to eq(participant1)
end
end
</pre>

=== The submitted_files(path = self.path) Method ===
This function in assignment_team.rb returns a list of files belonging to a team for a given path.

The unit test checks if the response is equal to the list of files that the team has submitted.

<pre>
describe "#submitted_files" do
context "given a path" do
it "returns submitted files" do
files = ["file1.rb"]
path = "assignment_path/5"
allow(team).to receive(:path).with(path)
allow(team).to receive(:files).with(path).and_return(files)
expect(team.submitted_files(path)).to match_array(files)
end
end
end
</pre>

=== The self.import(row, assignment_id, options) Method ===
This function in assignment_team.rb imports a team if the team with the given id is present.

The unit test checks if the team is not imported if the team with the given id is not already present.

context "when an assignment team does not already exist with the same id" do
it "cannot be imported" do
assignment_id = 1
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(nil)
error_message = "The assignment with the id \"" + assignment_id.to_s + "\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
expect { AssignmentTeam.import([], assignment_id, []) }.
to raise_error(ImportError, error_message)
end
end

The unit test checks if the team is imported if the team with the given id is already present.

context "when an assignment team with the same id already exists" do
it "gets imported through Team.import" do
row = []
assignment_id = 1
options = []
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(assignment)
allow(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
expect(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
AssignmentTeam.import(row, assignment_id, options)
end
end

=== The self.export(csv, parent_id, options) Method ===
This function in assignment_team.rb exports an instance of class '''AssignmentTeam'''

The unit test checks if the response is a new instance of the class '''AssignmentTeam''' or not.

<pre>
describe ".export" do
it "redirects to Team.export with a new AssignmentTeam object" do
allow(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
expect(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
AssignmentTeam.export([], 1, [])
end
end
</pre>

=== The copy(course_id) Method ===
This function in assignment_team.rb copies the current assignment team and creates a new CourseTeam instance from the given team. It takes as parameter the id of the course assignment team has.

The test grabs the course id from the assignment team and calls the function to check if a course team is successfully created or not. The function returns and empty array, otherwise returns '''nil''' if the course team is not created successfully.
<pre>
context "for given assignment team" do
it "copies the assignment team to course team" do
assignment = team.assignment
course = assignment.course
expect(team.copy(course.id)).to eq([])
end
end
</pre>

=== The add_participant(assignment_id, user) Method ===
This function in assignment_team.rb adds the user to the AssignmentTeam for the given assignment.

The unit test creates a user, and passes the user, assignment id for the team to the function and expects the result to be an instance of '''AssignmentParticipant''' meaning the user was successfully added as a participant.
<pre>
context "when a user is not a part of the team" do
it "adds the user to the team" do
user = build(:student, id: 10)
assignment = team.assignment
expect(team.add_participant(assignment.id, user)).to be_an_instance_of(AssignmentParticipant)
end
end
</pre>
 
The unit test creates a user, adds him as a participant to the team, and passes the user, assignment id for the team to the function and expects the result to be '''nil''' as the user already exists as participant of the team.
<pre>
context "when a user is already a part of the team" do
it "returns without adding user to the team" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
assignment = team.assignment
expect(team.add_participant(assignment.id, user1)).to eq(nil)
end
end
</pre>

=== The scores(questions) Method ===
This function in assignment_team.rb returns the total score of the team. This function calculates scores for a given hash of questions.

The unit test checks if the response is equal to the score.

<pre>
describe "#scores" do
context "when a hash of question is given" do
it "returns the score received by the team" do
questionnaire1 = build(:questionnaire, id: 1)
questionnaire2 = build(:questionnaire, id: 2)

question1 = build(:question, id: 1, questionnaire: questionnaire1)
question2 = build(:question, id: 2, questionnaire: questionnaire2)
questions = {questionnaire1.symbol => [question1], questionnaire2.symbol => [question2]}

scores = {}
scores[:team] = team
scores[:questionnaire1] = {}
scores[:questionnaire1][:assessments] = review_response_map
scores[:questionnaire1][:scores] = 5
scores[:questionnaire2] = {}
scores[:questionnaire2][:assessments] = review_response_map
scores[:questionnaire2][:scores] = 5
scores[:total_score] = 10

allow(team.assignment).to receive(:questionnaires).with(no_args).and_return([questionnaire1, questionnaire2])
allow(ReviewResponseMap).to receive(:where).with(reviewee_id: team.id).and_return(review_response_map)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire1][:assessments], questions[:questionnaire1]).and_return(5)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire2][:assessments], questions[:questionnaire2]).and_return(5)
allow(questionnaire1).to receive(:symbol).with(no_args).and_return(:questionnaire1)
allow(questionnaire2).to receive(:symbol).with(no_args).and_return(:questionnaire2)
allow(team.assignment).to receive(:compute_total_score).with(scores.except(:total_score)).and_return(10)
expect(team.scores(questions)).to eq(scores)
end
end
end

</pre>

=== The files(directory) Method ===
This method in assignment_team.rb successfully returns a list of files in any given directory path, not just the assignment teams directory path.

The unit test assigns the directory path as given below and checks if the list of files returned contains a specific file which is known to be in the list.
<pre>
context "when file is present in the directory" do
it "provides the list of files in directory and checks if file is present" do
directory = "spec/models"
expect(team.files(directory)).to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

The unit test assigns the directory path as given below and checks if the list of files returned does not contain a specific file which is known to not be in the list.
<pre>
context "when file is not present in the directory" do
it "provides the list of files in directory and checks if file is not present" do
directory = "spec/controllers"
expect(team.files(directory)).not_to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

=== The submit_hyperlink(hyperlink) Method ===
This function in assignment_team.rb submits the hyperlink for the team if it is valid or not empty.

The unit test checks if the hyperlink is empty and raises an error.
<pre>
context "when a hyperlink is empty" do
it "causes an exception to be raised" do
expect { team.submit_hyperlink("") }.to raise_error("The hyperlink cannot be empty!")
end
end
</pre>

The unit test checks if the hyperlink is invalid and raises a 404 error.
<pre>
context "when a hyperlink is invalid" do
it "causes an exception to be raised with the proper HTTP status code" do
invalid_hyperlink = "https://expertiza.ncsu.edu/not_a_valid_path"
allow(Net::HTTP).to receive(:get_response).and_return("404")
expect { team.submit_hyperlink(invalid_hyperlink) }.to raise_error("HTTP status code: 404")
end
end
</pre>

The unit test checks if the the hyperlink has been submitted or not.
context "when a valid hyperlink not in a certain improper format is submitted" do
it "it is fixed and is saved to the database" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu"])
allow(team).to receive(:submitted_hyperlinks=)
allow(team).to receive(:save)
allow(Net::HTTP).to receive(:get_response).and_return("0")
allow(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "http://www.ncsu.edu"])
team.submit_hyperlink("www.ncsu.edu ")
end
end
end
</pre>

=== The remove_hyperlink(hyperlink_to_delete) Method ===
This function in assignment_team.rb removes the hyperlink submitted by the team.

The unit test checks if the hyperlink has been deleted or not.
describe "#remove_hyperlink" do
context "when the hyperlink is in the assignment team's hyperlinks" do
it "is removed from the team's list of hyperlinks" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu", "https://www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu"])
team.remove_hyperlink("https://www.ncsu.edu")
end
end
end

=== The self.team(participant) Method ===
This function in assignment_team.rb returns the AssingmentTeam object that the given participant belongs to.

The unit test first builds a user and assigns that user as a participant1 of the team. Then allows that participant to be added as a team user and finally search the team for the given team user and expect the team for participant1 to be equal to the AssignmentTeam.
<pre>
context "when there is a participant" do
it "provides the team for participant" do
teamuser = build(:team_user, id: 1, team_id: team.id, user_id: user1.id)
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(TeamsUser).to receive(:where).with(user_id: participant1.user_id).and_return([teamuser])
allow(Team).to receive(:find).with(teamuser.team_id).and_return(team)
expect(AssignmentTeam.team(participant1)).to eq(team)
end
end
</pre>

=== The self.export_fields(options) Method ===
This function in assignment_team.rb exports the fields for a given set of options. It always returns a list containing ["Team Name", "Assignment Name"] if the given set of options have a team name set to true.

The unit test expects the method to return a static list of strings for the team passed as options, with the team having a name.
<pre>
context "when team has name" do
it "exports the fields" do
expect(AssignmentTeam.export_fields(team)).to eq(["Team Name", "Assignment Name"])
end
end
</pre>

=== The self.remove_team_by_id(id) Method ===
This function in assignment_team.rb removes team by using its id.

The unit test deletes the team by using its id and checks if return value is the instance of class '''AssignmentTeam'''.

<pre>
describe ".remove_team_by_id" do
context "when a team has an id" do
it "delete the team by id" do
allow(AssignmentTeam).to receive(:find).with(team.id).and_return(team)
expect(AssignmentTeam.remove_team_by_id(team.id)).to eq(team)
end
end
end
</pre>

=== The path Method ===
This function in assignment_team.rb returns a path to the directory where the team has submitted their files.

The unit test checks if the response is equal to the path belonging to the team's submission.
<pre>
describe "#path" do
it "returns the path" do
allow(team).to receive_message_chain(:assignment, :path).and_return("assignment_path")
allow(team).to receive(:directory_num).and_return(5)
expect(team.path).to eq "assignment_path/5"
end
end
</pre>

=== The set_student_directory_num Method ===
This function in assignment_team.rb sets the directory number for the team.

The unit test checks if the directory number for the team has been set. The test will check if the return value is equal to true.

<pre>
describe "#set_student_directory_num" do
it "sets the directory for the team" do
team = build(:assignment_team, id: 1, parent_id: 1, directory_num: -1)
max_num = 0
allow(AssignmentTeam).to receive_message_chain(:where, :order, :first, :directory_num).
with(parent_id: team.parent_id).with(:directory_num, :desc).with(no_args).with(no_args).and_return(max_num)
expect(team.set_student_directory_num).to be true
end
end
</pre>

=== The received_any_peer_review? Method ===
This function in assignment_team.rb checks if the team has received any peer reviews.

The unit test checks if any instance of '''ReviewResponseMap''' is present for the team.

<pre>
describe "#received_any_peer_review?" do
it "checks if the team has received any reviews" do
allow(ResponseMap).to receive_message_chain(:where, :any?).with(reviewee_id: team.id, reviewed_object_id: team.parent_id).with(no_args).and_return(true)
expect(team.received_any_peer_review?).to be true
end
end
</pre>

== Test Design ==
We used multiple RSpec-specific and general industry best practices for testing in our unit tests. A description of our use of some of these techniques follows.

=== Test Structure ===
We exploited '''describe''' blocks in RSpec to give our unit tests a readable structure. We had '''describe''' blocks for each method of '''AssignmentTeam'''. In these blocks, we used RSpec '''context''' blocks where appropriate and examples to identify and test the different cases in the source code.

=== Stubs for Isolating the UUT ===
In order to isolate the unit under test (UUT), i.e. the current method under test, we employed RSpec stubs. We stubbed out database calls and methods that triggered them in order to improve the run time of the unit tests, and we also stubbed out some outgoing command and query messages in order to test only the current method under test.

=== DRY Testing Practices ===
We exploited factories and the RSpec helper method '''let''' to make our unit tests shorter, more readable, and more maintainable, or, in essence, DRYer. Using the FactoryBot factories in '''factories.rb''' allowed us to use real Expertiza objects in our unit tests. We used the '''FactoryBot.build''' method to make our objects in order to avoid the run time penalty of saving (and this later having to retrieve) objects from the database. We used the '''let''' method with the factory as in the example below to make lazy-allocated objects which are cached throughout each example, improving run time.

<pre>let(:team) { build(:assignment_team, id: 1, parent_id: 1) }</pre>

Whenever '''team''' is called in an example, it returns the same value, i.e. the same object, which essentially allows tests that need it to have access to the same object without the need for allocating it as a class variable or instance variable for all of the tests or some of the tests. We placed these statements outside the scope of our unit test examples so the same objects could be used throughout all of them, DRYing out the test code.

== Testing Framework ==

=== RSpec Introduction ===
[http://rspec.info/ RSPEC] is a testing framework for Ruby for behavior-driven development (BDD) licensed under MIT. It is inspired by JBehave and contains fully integrated JMock based framework which has a very rich and powerful DSL (domain-specific language) which resembles a natural language specification. Composed of multiple libraries structured to work together, RSpec provides encapsulated testing via the describe block to specify the behavior of the class and the context for the unit test case.

=== Why RSpec? ===
RSpec is easy to learn and implement and can be used with other testing tools like Cucumber and Minitest independently. It is extremely powerful for testing states with complicated setup and also helps in tearing down complex code to access the objects required for testing RSpec semantics encourage agile thinking and practice and it structures the tests in a more intuitive way.

== Bugs Fixed ==
During testing of the '''AssignmentTeam''' model, we found two bugs, one in '''AssignmentTeam#submit_hyperlink''' and one in '''AssignmentTeam.import'''. In '''AssignmentTeam#submit_hyperlink''', '''http://''' was ''appended'' to hyperlink strings without this tag or
'''https://''' at the start of them, rather than ''prepended''. We fixed this error in our pull request. In '''AssignmentTeam.import''', '''id''', an undefined parameter, was referenced while raising an exception, and we updated it to '''assignment_id''', which was the actual name of the parameter passed to the method.

== Results ==
The model has a total of 237 lines, out of which 127 were relevant lines.
We achieved 100% coverage with avg hits per line at 2.3 (the number of times each specific line was run during the test suite)

[[File:Coverage_header.png]]
[[File:Coverage_line.png]]

== Future Work ==

DRY principle could be cleaned up a little more. Sometimes it became necessary to use the '''let''' or '''build''' helper methods in each unit test. They may all be consolidated at the beginning. 
Some more edge cases could be thought of for each method, and tests written for those. Although, we have tried to cover as many as possible. 
Additionally, in the future, the code may also be refactored with a more efficient tool. 
Test coverage through quality tests consistently added throughout the development of the Expertiza project should be the future work of the project. 

== References ==
1. [http://expertiza.ncsu.edu Expertiza] 
2. [http://wiki.expertiza.ncsu.edu/index.php/Main_Page#Expertiza Expertiza Wikipedia ] 
3. [https://github.com/expertiza/expertiza Expertiza Github Repository] 
4. [https://relishapp.com/rspec RSpec - Relish] 
5. [https://sites.google.com/site/longlastingsoftware Engineering Software as a Service]

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T20:37:49Z

Kaacken2: /* DRY Testing Practices */ Cut out the subheading and the reference to context blocks.

The purpose of this project is to improve the coverage and quality of the unit tests for the assignment team model in Expertiza. This project comprised the program 3 assignment of CSC/ECE 517 in fall 2018 and is entitled "Project E1848: Writing unit tests for assignment_team.rb." The source code for this project is in [https://github.com/expertiza/expertiza/pull/1228 pull request #1228] of the [https://github.com/expertiza Expertiza project] on [https://github.com/ GitHub].

== Key Contributions ==

Out of the 30 methods defined for the model AssignmentTeam.rb, test case was written for only one. Our contribution was to successfully add test cases for all remaining 29 methods.

Hence, increasing the coverage from 5% to 100%.

== The Class under Test ==
'''AssignmentTeam''' 
This class handles all functionalities for a team linked to an assignment. Some of the functionalities include, get a list of participants in the team, get the team name, team score for the given assignment, submissions for this team (files) and (hyperlinks) and topic picked by the team. Add/or remove participants from the team. It also checks for any reviews the team may have gotten for their work. Export all teams in a CSV file, import files from CSV to form teams.

== Test Plan ==
Our test plan was to test every method individually, i.e. write unit tests. We also tested multiple cases for each method. A description of all the methods in the '''AssignmentTeam''' model in assignment_team.rb and the RSpec unit tests we wrote for them is below.

==== '''Function name: includes?(participant)''' ====
This function in assignment_team.rb checks if the '''participant''' passed as argument is a member of the team or not. For this, we utilize factorybot to build a user and a participant1 as follows-:
<pre>
let(:user1) { build(:student, id: 2) }
let(:participant1) { build(:participant, id: 1) }
</pre>

Test cases checked for are-: 
1) when the team receives a user, that user is allowed to become a team participant. The method returns '''True''' for the given participant passed as argument.

<pre>
context "when an assignment team has one participant" do
it "includes one participant" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
expect(team.includes?(participant1)).to eq true
end
end
</pre>

2) when the team receives a user with no arguments, that user is '''not''' allowed to become a team participant. The method returns '''False''' for the given participant passed as argument.

<pre>
context "when an assignment team has no users" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([])
expect(team.includes?(participant1)).to eq false
end
end
</pre>

==== Function name: parent_model ====
This function in assignment_team.rb always provides the name of the parent model which is '''Assignment'''.

Hence, the unit test also always checks if the response of this method is the string '''"Assignment"''' or not.
<pre>
it "provides the name of the parent model" do
expect(team.parent_model).to eq "Assignment"
end
</pre>

==== Function name: self.parent_model(id) ====
This function in assignment_team.rb takes in as argument id of the current '''Assignment''' for the team and returns an instance of the parent model.

Hence the unit test checks if the instance returned by this method for a given assignment id, matches the assignment or not.
<pre>
it "provides the instance of the parent model" do
allow(Assignment).to receive(:find).with(1).and_return(assignment)
expect(AssignmentTeam.parent_model(1)).to eq assignment
end
</pre>

==== Function name: fullname ====
This function in assignment_team.rb print out the name for the current class instance. for this we first build an assignment team instance and assign it the name '''"abcd"'''.

Hence the unit test checks if the assignment team has a name, and returns that same name.
<pre>
context "when the team has a name" do
it "provides the name of the class" do
team = build(:assignment_team, id: 1, name: "abcd")
expect(team.fullname).to eq "abcd"
end
end
</pre>

==== Function name: review_map_type ====
This function in assignment_team.rb always provides the name of the review map type which is '''ReviewResponseMap'''.

Hence, the unit test also always checks if the response of this method is the string '''"ReviewResponseMap"''' or not.
<pre>
it "provides the review map type" do
expect(team.review_map_type).to eq "ReviewResponseMap"
end
</pre>

==== Function name: self.prototype ====
This function in assignment_team.rb implements the prototype pattern by returning a new instance of the class '''AssignmentTeam'''.

The unit test checks if the response is a new instance of the class or not.
<pre>
it "provides the instance of the AssignmentTeam" do
expect(AssignmentTeam).to receive(:new).with(no_args)
AssignmentTeam.prototype
end
</pre>

==== Function name: assign_reviewer(reviewer) ====
This function in assignment_team.rb assigns a reviewer to the team by returning a new instance of the class '''ReviewResponseMap'''.

The unit test assigns a reviewer to the team and creates an instance of ReviewResponseMap.
<pre>
describe "#assign_reviewer" do
context "when a reviewer is present" do
it "assign the reviewer to the team" do
allow(Assignment).to receive(:find).with(team.parent_id).and_return(assignment)
allow(ReviewResponseMap).to receive(:create).
with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: assignment.id).and_return(review_response_map)
expect(team.assign_reviewer(participant1)).to eq(review_response_map)
end
end
end
</pre>

==== Function name: reviewed_by?(reviewer) ====
This function in assignment_team.rb checks if the team has been reviewed by a reviewer.

The unit test checks if the reviewer has reviewed the team. The test will find instances of ReviewResponseMaps belonging to the reviewer and the team, and will return true if such instances are present.

<pre>
describe "#reviewed_by?" do
context "when a team has a reviewer" do
it "has been reviewed by this reviewer" do
template = 'reviewee_id = ? && reviewer_id = ? && reviewed_object_id = ?'
allow(ReviewResponseMap).to receive(:where).with(template, team.id, participant1.id, team.assignment.id).and_return([review_response_map])
expect(team.reviewed_by?(participant1)).to eq true
end
end
</pre>

==== Function name: topic ====
This function in assignment_team.rb return the id of the topic picked by the team for the assignment.

The unit test first stubs a topic for the given assignment, allows a SignedUpTeam object to receive that topic and AssignmentTeam id, and return the topic id to check if it matches with the topic id of the AssignmentTeam.
<pre>
context "when the team has picked a topic" do
it "provides the topic id" do
assignment = team.assignment
allow(SignUpTopic).to receive(:find_by).with(assignment: assignment).and_return(topic)
allow(SignedUpTeam).to receive_message_chain(:find_by, :try).with(team_id: team.id).with(:topic_id).and_return(topic.id)
expect(team.topic).to eq(topic.id)
end
end
</pre>

==== Function name: has_submissions? ====
this function in assignment_team.rb is used to check if the team has submitted their work or not.

The unit test allows the team to receive submissions, by first receiving files as submission, then hyperlink as submission, and for each expects the the team's submission to be true when the function is called.
<pre>
context "when a team has submitted files" do
it "has submissions" do
allow(team).to receive_message_chain(:submitted_files, :any?).with(no_args).with(no_args).and_return(true)
end
end

context "when the team has submitted hyperlink" do
it "checks if the team has submissions" do
allow(team).to receive_message_chain(:submitted_hyperlinks, :present?).with(no_args).with(no_args).and_return(true)
end
end

after(:each) do
expect(team.has_submissions?).to be true
end
</pre>

==== Function name: participants ====
This function in assignment_team.rb returns a list of all participants in the team.

The unit test first allows the team to receive two user instances and then adds these users as participants of the team. The test then expects the function to return a list of these two users as participants of the team.
<pre>
context "when an assignment team has two participants" do
it "has those two participants" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.participants).to eq [participant1, participant2]
end
end
</pre>

The unit test first allows the team to receive a user instance but does not add this user as participant of the team. The test then expects the function to return an empty list as participants of the team.
<pre>
context "when an assignment team has a user but no participants" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(nil)
expect(team.participants).to eq []
end
end
</pre>

==== Function name: delete ====
This function in assignment_team.rb deletes the AssignmentTeam by destroying each participant in the team and returns an instance of AssignmentTeam.

The unit test first allows two users to be added as team participants. The test checks if the team deleted matches the current team instance.

<pre>
it "deletes the team" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.delete).to eq(team)
end
</pre>

==== Function name: destroy ====
This function in assignment_team.rb deletes all the reviews associated with the team.

The unit test will delete every instance of '''ReviewResponseMaps''' associated with the team.
<pre>
describe "#destroy" do
it "delete the reviews" do
expect(team).to receive_message_chain(:review_response_maps, :each).with(no_args).with(no_args)
team.destroy
end
end
</pre>

==== Function name: self.get_first_member(team_id) ====
This function in assignment_team.rb returns the instance of the first participant of the team for the given team id.

The unit test allows the assignment to receive a user, add it as a participant and return the first participant in the team. The test expects the function to return an instance of this participant.
<pre>
context "when team id is present" do
it "get first member of the team" do
allow(AssignmentTeam).to receive_message_chain(:find_by, :try, :try).with(id: team.id).with(:participant).with(:first).and_return(participant1)
expect(AssignmentTeam.get_first_member(team.id)).to eq(participant1)
end
end
</pre>

==== Function name: submitted_files(path = self.path) ====
This function in assignment_team.rb returns a list of files belonging to a team for a given path.

The unit test checks if the response is equal to the list of files that the team has submitted.

<pre>
describe "#submitted_files" do
context "given a path" do
it "returns submitted files" do
files = ["file1.rb"]
path = "assignment_path/5"
allow(team).to receive(:path).with(path)
allow(team).to receive(:files).with(path).and_return(files)
expect(team.submitted_files(path)).to match_array(files)
end
end
end
</pre>

==== Function name: self.import(row, assignment_id, options) ====
This function in assignment_team.rb imports a team if the team with the given id is present.

The unit test checks if the team is not imported if the team with the given id is not already present.

context "when an assignment team does not already exist with the same id" do
it "cannot be imported" do
assignment_id = 1
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(nil)
error_message = "The assignment with the id \"" + assignment_id.to_s + "\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
expect { AssignmentTeam.import([], assignment_id, []) }.
to raise_error(ImportError, error_message)
end
end

The unit test checks if the team is imported if the team with the given id is already present.

context "when an assignment team with the same id already exists" do
it "gets imported through Team.import" do
row = []
assignment_id = 1
options = []
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(assignment)
allow(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
expect(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
AssignmentTeam.import(row, assignment_id, options)
end
end

==== Function name: self.export(csv, parent_id, options) ====
This function in assignment_team.rb exports an instance of class '''AssignmentTeam'''

The unit test checks if the response is a new instance of the class '''AssignmentTeam''' or not.

<pre>
describe ".export" do
it "redirects to Team.export with a new AssignmentTeam object" do
allow(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
expect(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
AssignmentTeam.export([], 1, [])
end
end
</pre>

==== Function name: copy(course_id) ====
This function in assignment_team.rb copies the current assignment team and creates a new CourseTeam instance from the given team. It takes as parameter the id of the course assignment team has.

The test grabs the course id from the assignment team and calls the function to check if a course team is successfully created or not. The function returns and empty array, otherwise returns '''nil''' if the course team is not created successfully.
<pre>
context "for given assignment team" do
it "copies the assignment team to course team" do
assignment = team.assignment
course = assignment.course
expect(team.copy(course.id)).to eq([])
end
end
</pre>

==== Function name: add_participant(assignment_id, user) ====
This function in assignment_team.rb adds the user to the AssignmentTeam for the given assignment.

The unit test creates a user, and passes the user, assignment id for the team to the function and expects the result to be an instance of '''AssignmentParticipant''' meaning the user was successfully added as a participant.
<pre>
context "when a user is not a part of the team" do
it "adds the user to the team" do
user = build(:student, id: 10)
assignment = team.assignment
expect(team.add_participant(assignment.id, user)).to be_an_instance_of(AssignmentParticipant)
end
end
</pre>
 
The unit test creates a user, adds him as a participant to the team, and passes the user, assignment id for the team to the function and expects the result to be '''nil''' as the user already exists as participant of the team.
<pre>
context "when a user is already a part of the team" do
it "returns without adding user to the team" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
assignment = team.assignment
expect(team.add_participant(assignment.id, user1)).to eq(nil)
end
end
</pre>

==== Function name: scores(questions) ====
This function in assignment_team.rb returns the total score of the team. This function calculates scores for a given hash of questions.

The unit test checks if the response is equal to the score.

<pre>
describe "#scores" do
context "when a hash of question is given" do
it "returns the score received by the team" do
questionnaire1 = build(:questionnaire, id: 1)
questionnaire2 = build(:questionnaire, id: 2)

question1 = build(:question, id: 1, questionnaire: questionnaire1)
question2 = build(:question, id: 2, questionnaire: questionnaire2)
questions = {questionnaire1.symbol => [question1], questionnaire2.symbol => [question2]}

scores = {}
scores[:team] = team
scores[:questionnaire1] = {}
scores[:questionnaire1][:assessments] = review_response_map
scores[:questionnaire1][:scores] = 5
scores[:questionnaire2] = {}
scores[:questionnaire2][:assessments] = review_response_map
scores[:questionnaire2][:scores] = 5
scores[:total_score] = 10

allow(team.assignment).to receive(:questionnaires).with(no_args).and_return([questionnaire1, questionnaire2])
allow(ReviewResponseMap).to receive(:where).with(reviewee_id: team.id).and_return(review_response_map)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire1][:assessments], questions[:questionnaire1]).and_return(5)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire2][:assessments], questions[:questionnaire2]).and_return(5)
allow(questionnaire1).to receive(:symbol).with(no_args).and_return(:questionnaire1)
allow(questionnaire2).to receive(:symbol).with(no_args).and_return(:questionnaire2)
allow(team.assignment).to receive(:compute_total_score).with(scores.except(:total_score)).and_return(10)
expect(team.scores(questions)).to eq(scores)
end
end
end

</pre>

==== Function name: files(directory) ====
This method in assignment_team.rb successfully returns a list of files in any given directory path, not just the assignment teams directory path.

The unit test assigns the directory path as given below and checks if the list of files returned contains a specific file which is known to be in the list.
<pre>
context "when file is present in the directory" do
it "provides the list of files in directory and checks if file is present" do
directory = "spec/models"
expect(team.files(directory)).to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

The unit test assigns the directory path as given below and checks if the list of files returned does not contain a specific file which is known to not be in the list.
<pre>
context "when file is not present in the directory" do
it "provides the list of files in directory and checks if file is not present" do
directory = "spec/controllers"
expect(team.files(directory)).not_to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

==== Function name: submit_hyperlink(hyperlink) ====
This function in assignment_team.rb submits the hyperlink for the team if it is valid or not empty.

The unit test checks if the hyperlink is empty and raises an error.
<pre>
context "when a hyperlink is empty" do
it "causes an exception to be raised" do
expect { team.submit_hyperlink("") }.to raise_error("The hyperlink cannot be empty!")
end
end
</pre>

The unit test checks if the hyperlink is invalid and raises a 404 error.
<pre>
context "when a hyperlink is invalid" do
it "causes an exception to be raised with the proper HTTP status code" do
invalid_hyperlink = "https://expertiza.ncsu.edu/not_a_valid_path"
allow(Net::HTTP).to receive(:get_response).and_return("404")
expect { team.submit_hyperlink(invalid_hyperlink) }.to raise_error("HTTP status code: 404")
end
end
</pre>

The unit test checks if the the hyperlink has been submitted or not.
context "when a valid hyperlink not in a certain improper format is submitted" do
it "it is fixed and is saved to the database" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu"])
allow(team).to receive(:submitted_hyperlinks=)
allow(team).to receive(:save)
allow(Net::HTTP).to receive(:get_response).and_return("0")
allow(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "http://www.ncsu.edu"])
team.submit_hyperlink("www.ncsu.edu ")
end
end
end
</pre>

==== Function name: remove_hyperlink(hyperlink_to_delete) ====
This function in assignment_team.rb removes the hyperlink submitted by the team.

The unit test checks if the hyperlink has been deleted or not.
describe "#remove_hyperlink" do
context "when the hyperlink is in the assignment team's hyperlinks" do
it "is removed from the team's list of hyperlinks" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu", "https://www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu"])
team.remove_hyperlink("https://www.ncsu.edu")
end
end
end

==== Function name: self.team(participant) ====
This function in assignment_team.rb returns the AssingmentTeam object that the given participant belongs to.

The unit test first builds a user and assigns that user as a participant1 of the team. Then allows that participant to be added as a team user and finally search the team for the given team user and expect the team for participant1 to be equal to the AssignmentTeam.
<pre>
context "when there is a participant" do
it "provides the team for participant" do
teamuser = build(:team_user, id: 1, team_id: team.id, user_id: user1.id)
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(TeamsUser).to receive(:where).with(user_id: participant1.user_id).and_return([teamuser])
allow(Team).to receive(:find).with(teamuser.team_id).and_return(team)
expect(AssignmentTeam.team(participant1)).to eq(team)
end
end
</pre>

==== Function name: self.export_fields(options) ====
This function in assignment_team.rb exports the fields for a given set of options. It always returns a list containing ["Team Name", "Assignment Name"] if the given set of options have a team name set to true.

The unit test expects the method to return a static list of strings for the team passed as options, with the team having a name.
<pre>
context "when team has name" do
it "exports the fields" do
expect(AssignmentTeam.export_fields(team)).to eq(["Team Name", "Assignment Name"])
end
end
</pre>

==== Function name: self.remove_team_by_id(id) ====
This function in assignment_team.rb removes team by using its id.

The unit test deletes the team by using its id and checks if return value is the instance of class '''AssignmentTeam'''.

<pre>
describe ".remove_team_by_id" do
context "when a team has an id" do
it "delete the team by id" do
allow(AssignmentTeam).to receive(:find).with(team.id).and_return(team)
expect(AssignmentTeam.remove_team_by_id(team.id)).to eq(team)
end
end
end
</pre>

==== Function name: path ====
This function in assignment_team.rb returns a path to the directory where the team has submitted their files.

The unit test checks if the response is equal to the path belonging to the team's submission.
<pre>
describe "#path" do
it "returns the path" do
allow(team).to receive_message_chain(:assignment, :path).and_return("assignment_path")
allow(team).to receive(:directory_num).and_return(5)
expect(team.path).to eq "assignment_path/5"
end
end
</pre>

==== Function name: set_student_directory_num ====
This function in assignment_team.rb sets the directory number for the team.

The unit test checks if the directory number for the team has been set. The test will check if the return value is equal to true.

<pre>
describe "#set_student_directory_num" do
it "sets the directory for the team" do
team = build(:assignment_team, id: 1, parent_id: 1, directory_num: -1)
max_num = 0
allow(AssignmentTeam).to receive_message_chain(:where, :order, :first, :directory_num).
with(parent_id: team.parent_id).with(:directory_num, :desc).with(no_args).with(no_args).and_return(max_num)
expect(team.set_student_directory_num).to be true
end
end
</pre>

==== Function name: received_any_peer_review? ====
This function in assignment_team.rb checks if the team has received any peer reviews.

The unit test checks if any instance of '''ReviewResponseMap''' is present for the team.

<pre>
describe "#received_any_peer_review?" do
it "checks if the team has received any reviews" do
allow(ResponseMap).to receive_message_chain(:where, :any?).with(reviewee_id: team.id, reviewed_object_id: team.parent_id).with(no_args).and_return(true)
expect(team.received_any_peer_review?).to be true
end
end
</pre>

== Test Design ==
We used multiple RSpec-specific and general industry best practices for testing in our unit tests. A description of our use of some of these techniques follows.

=== Test Structure ===
We exploited '''describe''' blocks in RSpec to give our unit tests a readable structure. We had '''describe''' blocks for each method of '''AssignmentTeam'''. In these blocks, we used RSpec '''context''' blocks where appropriate and examples to identify and test the different cases in the source code.

=== Stubs for Isolating the UUT ===
In order to isolate the unit under test (UUT), i.e. the current method under test, we employed RSpec stubs. We stubbed out database calls and methods that triggered them in order to improve the run time of the unit tests, and we also stubbed out some outgoing command and query messages in order to test only the current method under test.

=== DRY Testing Practices ===
We exploited factories and the RSpec helper method '''let''' to make our unit tests shorter, more readable, and more maintainable, or, in essence, DRYer. Using the FactoryBot factories in '''factories.rb''' allowed us to use real Expertiza objects in our unit tests. We used the '''FactoryBot.build''' method to make our objects in order to avoid the run time penalty of saving (and this later having to retrieve) objects from the database. We used the '''let''' method with the factory as in the example below to make lazy-allocated objects which are cached throughout each example, improving run time.

<pre>let(:team) { build(:assignment_team, id: 1, parent_id: 1) }</pre>

Whenever '''team''' is called in an example, it returns the same value, i.e. the same object, which essentially allows tests that need it to have access to the same object without the need for allocating it as a class variable or instance variable for all of the tests or some of the tests. We placed these statements outside the scope of our unit test examples so the same objects could be used throughout all of them, DRYing out the test code.

== Testing Framework ==

=== RSpec Introduction ===
[http://rspec.info/ RSPEC] is a testing framework for Ruby for behavior-driven development (BDD) licensed under MIT. It is inspired by JBehave and contains fully integrated JMock based framework which has a very rich and powerful DSL (domain-specific language) which resembles a natural language specification. Composed of multiple libraries structured to work together, RSpec provides encapsulated testing via the describe block to specify the behavior of the class and the context for the unit test case.

=== Why RSpec? ===
RSpec is easy to learn and implement and can be used with other testing tools like Cucumber and Minitest independently. It is extremely powerful for testing states with complicated setup and also helps in tearing down complex code to access the objects required for testing RSpec semantics encourage agile thinking and practice and it structures the tests in a more intuitive way.

== Bugs Fixed ==
During testing of the '''AssignmentTeam''' model, we found two bugs, one in '''AssignmentTeam#submit_hyperlink''' and one in '''AssignmentTeam.import'''. In '''AssignmentTeam#submit_hyperlink''', '''http://''' was ''appended'' to hyperlink strings without this tag or
'''https://''' at the start of them, rather than ''prepended''. We fixed this error in our pull request. In '''AssignmentTeam.import''', '''id''', an undefined parameter, was referenced while raising an exception, and we updated it to '''assignment_id''', which was the actual name of the parameter passed to the method.

== Results ==
The model has a total of 237 lines, out of which 127 were relevant lines.
We achieved 100% coverage with avg hits per line at 2.3 (the number of times each specific line was run during the test suite)

[[File:Coverage_header.png]]
[[File:Coverage_line.png]]

== Future Work ==

DRY principle could be cleaned up a little more. Sometimes it became necessary to use the '''let''' or '''build''' helper methods in each unit test. They may all be consolidated at the beginning. 
Some more edge cases could be thought of for each method, and tests written for those. Although, we have tried to cover as many as possible. 
Additionally, in the future, the code may also be refactored with a more efficient tool. 
Test coverage through quality tests consistently added throughout the development of the Expertiza project should be the future work of the project. 

== References ==
1. [http://expertiza.ncsu.edu Expertiza] 
2. [http://wiki.expertiza.ncsu.edu/index.php/Main_Page#Expertiza Expertiza Wikipedia ] 
3. [https://github.com/expertiza/expertiza Expertiza Github Repository] 
4. [https://relishapp.com/rspec RSpec - Relish] 
5. [https://sites.google.com/site/longlastingsoftware Engineering Software as a Service]

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T20:36:48Z

Kaacken2: Edit the Test Design and Test Structure sections.

The purpose of this project is to improve the coverage and quality of the unit tests for the assignment team model in Expertiza. This project comprised the program 3 assignment of CSC/ECE 517 in fall 2018 and is entitled "Project E1848: Writing unit tests for assignment_team.rb." The source code for this project is in [https://github.com/expertiza/expertiza/pull/1228 pull request #1228] of the [https://github.com/expertiza Expertiza project] on [https://github.com/ GitHub].

== Key Contributions ==

Out of the 30 methods defined for the model AssignmentTeam.rb, test case was written for only one. Our contribution was to successfully add test cases for all remaining 29 methods.

Hence, increasing the coverage from 5% to 100%.

== The Class under Test ==
'''AssignmentTeam''' 
This class handles all functionalities for a team linked to an assignment. Some of the functionalities include, get a list of participants in the team, get the team name, team score for the given assignment, submissions for this team (files) and (hyperlinks) and topic picked by the team. Add/or remove participants from the team. It also checks for any reviews the team may have gotten for their work. Export all teams in a CSV file, import files from CSV to form teams.

== Test Plan ==
Our test plan was to test every method individually, i.e. write unit tests. We also tested multiple cases for each method. A description of all the methods in the '''AssignmentTeam''' model in assignment_team.rb and the RSpec unit tests we wrote for them is below.

==== '''Function name: includes?(participant)''' ====
This function in assignment_team.rb checks if the '''participant''' passed as argument is a member of the team or not. For this, we utilize factorybot to build a user and a participant1 as follows-:
<pre>
let(:user1) { build(:student, id: 2) }
let(:participant1) { build(:participant, id: 1) }
</pre>

Test cases checked for are-: 
1) when the team receives a user, that user is allowed to become a team participant. The method returns '''True''' for the given participant passed as argument.

<pre>
context "when an assignment team has one participant" do
it "includes one participant" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
expect(team.includes?(participant1)).to eq true
end
end
</pre>

2) when the team receives a user with no arguments, that user is '''not''' allowed to become a team participant. The method returns '''False''' for the given participant passed as argument.

<pre>
context "when an assignment team has no users" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([])
expect(team.includes?(participant1)).to eq false
end
end
</pre>

==== Function name: parent_model ====
This function in assignment_team.rb always provides the name of the parent model which is '''Assignment'''.

Hence, the unit test also always checks if the response of this method is the string '''"Assignment"''' or not.
<pre>
it "provides the name of the parent model" do
expect(team.parent_model).to eq "Assignment"
end
</pre>

==== Function name: self.parent_model(id) ====
This function in assignment_team.rb takes in as argument id of the current '''Assignment''' for the team and returns an instance of the parent model.

Hence the unit test checks if the instance returned by this method for a given assignment id, matches the assignment or not.
<pre>
it "provides the instance of the parent model" do
allow(Assignment).to receive(:find).with(1).and_return(assignment)
expect(AssignmentTeam.parent_model(1)).to eq assignment
end
</pre>

==== Function name: fullname ====
This function in assignment_team.rb print out the name for the current class instance. for this we first build an assignment team instance and assign it the name '''"abcd"'''.

Hence the unit test checks if the assignment team has a name, and returns that same name.
<pre>
context "when the team has a name" do
it "provides the name of the class" do
team = build(:assignment_team, id: 1, name: "abcd")
expect(team.fullname).to eq "abcd"
end
end
</pre>

==== Function name: review_map_type ====
This function in assignment_team.rb always provides the name of the review map type which is '''ReviewResponseMap'''.

Hence, the unit test also always checks if the response of this method is the string '''"ReviewResponseMap"''' or not.
<pre>
it "provides the review map type" do
expect(team.review_map_type).to eq "ReviewResponseMap"
end
</pre>

==== Function name: self.prototype ====
This function in assignment_team.rb implements the prototype pattern by returning a new instance of the class '''AssignmentTeam'''.

The unit test checks if the response is a new instance of the class or not.
<pre>
it "provides the instance of the AssignmentTeam" do
expect(AssignmentTeam).to receive(:new).with(no_args)
AssignmentTeam.prototype
end
</pre>

==== Function name: assign_reviewer(reviewer) ====
This function in assignment_team.rb assigns a reviewer to the team by returning a new instance of the class '''ReviewResponseMap'''.

The unit test assigns a reviewer to the team and creates an instance of ReviewResponseMap.
<pre>
describe "#assign_reviewer" do
context "when a reviewer is present" do
it "assign the reviewer to the team" do
allow(Assignment).to receive(:find).with(team.parent_id).and_return(assignment)
allow(ReviewResponseMap).to receive(:create).
with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: assignment.id).and_return(review_response_map)
expect(team.assign_reviewer(participant1)).to eq(review_response_map)
end
end
end
</pre>

==== Function name: reviewed_by?(reviewer) ====
This function in assignment_team.rb checks if the team has been reviewed by a reviewer.

The unit test checks if the reviewer has reviewed the team. The test will find instances of ReviewResponseMaps belonging to the reviewer and the team, and will return true if such instances are present.

<pre>
describe "#reviewed_by?" do
context "when a team has a reviewer" do
it "has been reviewed by this reviewer" do
template = 'reviewee_id = ? && reviewer_id = ? && reviewed_object_id = ?'
allow(ReviewResponseMap).to receive(:where).with(template, team.id, participant1.id, team.assignment.id).and_return([review_response_map])
expect(team.reviewed_by?(participant1)).to eq true
end
end
</pre>

==== Function name: topic ====
This function in assignment_team.rb return the id of the topic picked by the team for the assignment.

The unit test first stubs a topic for the given assignment, allows a SignedUpTeam object to receive that topic and AssignmentTeam id, and return the topic id to check if it matches with the topic id of the AssignmentTeam.
<pre>
context "when the team has picked a topic" do
it "provides the topic id" do
assignment = team.assignment
allow(SignUpTopic).to receive(:find_by).with(assignment: assignment).and_return(topic)
allow(SignedUpTeam).to receive_message_chain(:find_by, :try).with(team_id: team.id).with(:topic_id).and_return(topic.id)
expect(team.topic).to eq(topic.id)
end
end
</pre>

==== Function name: has_submissions? ====
this function in assignment_team.rb is used to check if the team has submitted their work or not.

The unit test allows the team to receive submissions, by first receiving files as submission, then hyperlink as submission, and for each expects the the team's submission to be true when the function is called.
<pre>
context "when a team has submitted files" do
it "has submissions" do
allow(team).to receive_message_chain(:submitted_files, :any?).with(no_args).with(no_args).and_return(true)
end
end

context "when the team has submitted hyperlink" do
it "checks if the team has submissions" do
allow(team).to receive_message_chain(:submitted_hyperlinks, :present?).with(no_args).with(no_args).and_return(true)
end
end

after(:each) do
expect(team.has_submissions?).to be true
end
</pre>

==== Function name: participants ====
This function in assignment_team.rb returns a list of all participants in the team.

The unit test first allows the team to receive two user instances and then adds these users as participants of the team. The test then expects the function to return a list of these two users as participants of the team.
<pre>
context "when an assignment team has two participants" do
it "has those two participants" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.participants).to eq [participant1, participant2]
end
end
</pre>

The unit test first allows the team to receive a user instance but does not add this user as participant of the team. The test then expects the function to return an empty list as participants of the team.
<pre>
context "when an assignment team has a user but no participants" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(nil)
expect(team.participants).to eq []
end
end
</pre>

==== Function name: delete ====
This function in assignment_team.rb deletes the AssignmentTeam by destroying each participant in the team and returns an instance of AssignmentTeam.

The unit test first allows two users to be added as team participants. The test checks if the team deleted matches the current team instance.

<pre>
it "deletes the team" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.delete).to eq(team)
end
</pre>

==== Function name: destroy ====
This function in assignment_team.rb deletes all the reviews associated with the team.

The unit test will delete every instance of '''ReviewResponseMaps''' associated with the team.
<pre>
describe "#destroy" do
it "delete the reviews" do
expect(team).to receive_message_chain(:review_response_maps, :each).with(no_args).with(no_args)
team.destroy
end
end
</pre>

==== Function name: self.get_first_member(team_id) ====
This function in assignment_team.rb returns the instance of the first participant of the team for the given team id.

The unit test allows the assignment to receive a user, add it as a participant and return the first participant in the team. The test expects the function to return an instance of this participant.
<pre>
context "when team id is present" do
it "get first member of the team" do
allow(AssignmentTeam).to receive_message_chain(:find_by, :try, :try).with(id: team.id).with(:participant).with(:first).and_return(participant1)
expect(AssignmentTeam.get_first_member(team.id)).to eq(participant1)
end
end
</pre>

==== Function name: submitted_files(path = self.path) ====
This function in assignment_team.rb returns a list of files belonging to a team for a given path.

The unit test checks if the response is equal to the list of files that the team has submitted.

<pre>
describe "#submitted_files" do
context "given a path" do
it "returns submitted files" do
files = ["file1.rb"]
path = "assignment_path/5"
allow(team).to receive(:path).with(path)
allow(team).to receive(:files).with(path).and_return(files)
expect(team.submitted_files(path)).to match_array(files)
end
end
end
</pre>

==== Function name: self.import(row, assignment_id, options) ====
This function in assignment_team.rb imports a team if the team with the given id is present.

The unit test checks if the team is not imported if the team with the given id is not already present.

context "when an assignment team does not already exist with the same id" do
it "cannot be imported" do
assignment_id = 1
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(nil)
error_message = "The assignment with the id \"" + assignment_id.to_s + "\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
expect { AssignmentTeam.import([], assignment_id, []) }.
to raise_error(ImportError, error_message)
end
end

The unit test checks if the team is imported if the team with the given id is already present.

context "when an assignment team with the same id already exists" do
it "gets imported through Team.import" do
row = []
assignment_id = 1
options = []
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(assignment)
allow(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
expect(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
AssignmentTeam.import(row, assignment_id, options)
end
end

==== Function name: self.export(csv, parent_id, options) ====
This function in assignment_team.rb exports an instance of class '''AssignmentTeam'''

The unit test checks if the response is a new instance of the class '''AssignmentTeam''' or not.

<pre>
describe ".export" do
it "redirects to Team.export with a new AssignmentTeam object" do
allow(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
expect(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
AssignmentTeam.export([], 1, [])
end
end
</pre>

==== Function name: copy(course_id) ====
This function in assignment_team.rb copies the current assignment team and creates a new CourseTeam instance from the given team. It takes as parameter the id of the course assignment team has.

The test grabs the course id from the assignment team and calls the function to check if a course team is successfully created or not. The function returns and empty array, otherwise returns '''nil''' if the course team is not created successfully.
<pre>
context "for given assignment team" do
it "copies the assignment team to course team" do
assignment = team.assignment
course = assignment.course
expect(team.copy(course.id)).to eq([])
end
end
</pre>

==== Function name: add_participant(assignment_id, user) ====
This function in assignment_team.rb adds the user to the AssignmentTeam for the given assignment.

The unit test creates a user, and passes the user, assignment id for the team to the function and expects the result to be an instance of '''AssignmentParticipant''' meaning the user was successfully added as a participant.
<pre>
context "when a user is not a part of the team" do
it "adds the user to the team" do
user = build(:student, id: 10)
assignment = team.assignment
expect(team.add_participant(assignment.id, user)).to be_an_instance_of(AssignmentParticipant)
end
end
</pre>
 
The unit test creates a user, adds him as a participant to the team, and passes the user, assignment id for the team to the function and expects the result to be '''nil''' as the user already exists as participant of the team.
<pre>
context "when a user is already a part of the team" do
it "returns without adding user to the team" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
assignment = team.assignment
expect(team.add_participant(assignment.id, user1)).to eq(nil)
end
end
</pre>

==== Function name: scores(questions) ====
This function in assignment_team.rb returns the total score of the team. This function calculates scores for a given hash of questions.

The unit test checks if the response is equal to the score.

<pre>
describe "#scores" do
context "when a hash of question is given" do
it "returns the score received by the team" do
questionnaire1 = build(:questionnaire, id: 1)
questionnaire2 = build(:questionnaire, id: 2)

question1 = build(:question, id: 1, questionnaire: questionnaire1)
question2 = build(:question, id: 2, questionnaire: questionnaire2)
questions = {questionnaire1.symbol => [question1], questionnaire2.symbol => [question2]}

scores = {}
scores[:team] = team
scores[:questionnaire1] = {}
scores[:questionnaire1][:assessments] = review_response_map
scores[:questionnaire1][:scores] = 5
scores[:questionnaire2] = {}
scores[:questionnaire2][:assessments] = review_response_map
scores[:questionnaire2][:scores] = 5
scores[:total_score] = 10

allow(team.assignment).to receive(:questionnaires).with(no_args).and_return([questionnaire1, questionnaire2])
allow(ReviewResponseMap).to receive(:where).with(reviewee_id: team.id).and_return(review_response_map)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire1][:assessments], questions[:questionnaire1]).and_return(5)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire2][:assessments], questions[:questionnaire2]).and_return(5)
allow(questionnaire1).to receive(:symbol).with(no_args).and_return(:questionnaire1)
allow(questionnaire2).to receive(:symbol).with(no_args).and_return(:questionnaire2)
allow(team.assignment).to receive(:compute_total_score).with(scores.except(:total_score)).and_return(10)
expect(team.scores(questions)).to eq(scores)
end
end
end

</pre>

==== Function name: files(directory) ====
This method in assignment_team.rb successfully returns a list of files in any given directory path, not just the assignment teams directory path.

The unit test assigns the directory path as given below and checks if the list of files returned contains a specific file which is known to be in the list.
<pre>
context "when file is present in the directory" do
it "provides the list of files in directory and checks if file is present" do
directory = "spec/models"
expect(team.files(directory)).to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

The unit test assigns the directory path as given below and checks if the list of files returned does not contain a specific file which is known to not be in the list.
<pre>
context "when file is not present in the directory" do
it "provides the list of files in directory and checks if file is not present" do
directory = "spec/controllers"
expect(team.files(directory)).not_to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

==== Function name: submit_hyperlink(hyperlink) ====
This function in assignment_team.rb submits the hyperlink for the team if it is valid or not empty.

The unit test checks if the hyperlink is empty and raises an error.
<pre>
context "when a hyperlink is empty" do
it "causes an exception to be raised" do
expect { team.submit_hyperlink("") }.to raise_error("The hyperlink cannot be empty!")
end
end
</pre>

The unit test checks if the hyperlink is invalid and raises a 404 error.
<pre>
context "when a hyperlink is invalid" do
it "causes an exception to be raised with the proper HTTP status code" do
invalid_hyperlink = "https://expertiza.ncsu.edu/not_a_valid_path"
allow(Net::HTTP).to receive(:get_response).and_return("404")
expect { team.submit_hyperlink(invalid_hyperlink) }.to raise_error("HTTP status code: 404")
end
end
</pre>

The unit test checks if the the hyperlink has been submitted or not.
context "when a valid hyperlink not in a certain improper format is submitted" do
it "it is fixed and is saved to the database" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu"])
allow(team).to receive(:submitted_hyperlinks=)
allow(team).to receive(:save)
allow(Net::HTTP).to receive(:get_response).and_return("0")
allow(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "http://www.ncsu.edu"])
team.submit_hyperlink("www.ncsu.edu ")
end
end
end
</pre>

==== Function name: remove_hyperlink(hyperlink_to_delete) ====
This function in assignment_team.rb removes the hyperlink submitted by the team.

The unit test checks if the hyperlink has been deleted or not.
describe "#remove_hyperlink" do
context "when the hyperlink is in the assignment team's hyperlinks" do
it "is removed from the team's list of hyperlinks" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu", "https://www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu"])
team.remove_hyperlink("https://www.ncsu.edu")
end
end
end

==== Function name: self.team(participant) ====
This function in assignment_team.rb returns the AssingmentTeam object that the given participant belongs to.

The unit test first builds a user and assigns that user as a participant1 of the team. Then allows that participant to be added as a team user and finally search the team for the given team user and expect the team for participant1 to be equal to the AssignmentTeam.
<pre>
context "when there is a participant" do
it "provides the team for participant" do
teamuser = build(:team_user, id: 1, team_id: team.id, user_id: user1.id)
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(TeamsUser).to receive(:where).with(user_id: participant1.user_id).and_return([teamuser])
allow(Team).to receive(:find).with(teamuser.team_id).and_return(team)
expect(AssignmentTeam.team(participant1)).to eq(team)
end
end
</pre>

==== Function name: self.export_fields(options) ====
This function in assignment_team.rb exports the fields for a given set of options. It always returns a list containing ["Team Name", "Assignment Name"] if the given set of options have a team name set to true.

The unit test expects the method to return a static list of strings for the team passed as options, with the team having a name.
<pre>
context "when team has name" do
it "exports the fields" do
expect(AssignmentTeam.export_fields(team)).to eq(["Team Name", "Assignment Name"])
end
end
</pre>

==== Function name: self.remove_team_by_id(id) ====
This function in assignment_team.rb removes team by using its id.

The unit test deletes the team by using its id and checks if return value is the instance of class '''AssignmentTeam'''.

<pre>
describe ".remove_team_by_id" do
context "when a team has an id" do
it "delete the team by id" do
allow(AssignmentTeam).to receive(:find).with(team.id).and_return(team)
expect(AssignmentTeam.remove_team_by_id(team.id)).to eq(team)
end
end
end
</pre>

==== Function name: path ====
This function in assignment_team.rb returns a path to the directory where the team has submitted their files.

The unit test checks if the response is equal to the path belonging to the team's submission.
<pre>
describe "#path" do
it "returns the path" do
allow(team).to receive_message_chain(:assignment, :path).and_return("assignment_path")
allow(team).to receive(:directory_num).and_return(5)
expect(team.path).to eq "assignment_path/5"
end
end
</pre>

==== Function name: set_student_directory_num ====
This function in assignment_team.rb sets the directory number for the team.

The unit test checks if the directory number for the team has been set. The test will check if the return value is equal to true.

<pre>
describe "#set_student_directory_num" do
it "sets the directory for the team" do
team = build(:assignment_team, id: 1, parent_id: 1, directory_num: -1)
max_num = 0
allow(AssignmentTeam).to receive_message_chain(:where, :order, :first, :directory_num).
with(parent_id: team.parent_id).with(:directory_num, :desc).with(no_args).with(no_args).and_return(max_num)
expect(team.set_student_directory_num).to be true
end
end
</pre>

==== Function name: received_any_peer_review? ====
This function in assignment_team.rb checks if the team has received any peer reviews.

The unit test checks if any instance of '''ReviewResponseMap''' is present for the team.

<pre>
describe "#received_any_peer_review?" do
it "checks if the team has received any reviews" do
allow(ResponseMap).to receive_message_chain(:where, :any?).with(reviewee_id: team.id, reviewed_object_id: team.parent_id).with(no_args).and_return(true)
expect(team.received_any_peer_review?).to be true
end
end
</pre>

== Test Design ==
We used multiple RSpec-specific and general industry best practices for testing in our unit tests. A description of our use of some of these techniques follows.

=== Test Structure ===
We exploited '''describe''' blocks in RSpec to give our unit tests a readable structure. We had '''describe''' blocks for each method of '''AssignmentTeam'''. In these blocks, we used RSpec '''context''' blocks where appropriate and examples to identify and test the different cases in the source code.

=== Stubs for Isolating the UUT ===
In order to isolate the unit under test (UUT), i.e. the current method under test, we employed RSpec stubs. We stubbed out database calls and methods that triggered them in order to improve the run time of the unit tests, and we also stubbed out some outgoing command and query messages in order to test only the current method under test.

=== DRY Testing Practices ===
We exploited factories and the RSpec helper method '''let''' as well as '''context''' blocks to make our unit tests shorter, more readable, and more maintainable, or, in essence, DRYer.

==== Factories and the let RSPEC Helper Method ====
Using the FactoryBot factories in '''factories.rb''' allowed us to use real Expertiza objects in our unit tests. We used the '''FactoryBot.build''' method to make our objects in order to avoid the run time penalty of saving (and this later having to retrieve) objects from the database. We used the '''let''' method with the factory as in the example below to make lazy-allocated objects which are cached throughout each example, improving run time.

<pre>let(:team) { build(:assignment_team, id: 1, parent_id: 1) }</pre>

Whenever '''team''' is called in an example, it returns the same value, i.e. the same object, which essentially allows tests that need it to have access to the same object without the need for allocating it as a class variable or instance variable for all of the tests or some of the tests. We placed these statements outside the scope of our unit test examples so the same objects could be used throughout all of them, DRYing out the test code.

== Testing Framework ==

=== RSpec Introduction ===
[http://rspec.info/ RSPEC] is a testing framework for Ruby for behavior-driven development (BDD) licensed under MIT. It is inspired by JBehave and contains fully integrated JMock based framework which has a very rich and powerful DSL (domain-specific language) which resembles a natural language specification. Composed of multiple libraries structured to work together, RSpec provides encapsulated testing via the describe block to specify the behavior of the class and the context for the unit test case.

=== Why RSpec? ===
RSpec is easy to learn and implement and can be used with other testing tools like Cucumber and Minitest independently. It is extremely powerful for testing states with complicated setup and also helps in tearing down complex code to access the objects required for testing RSpec semantics encourage agile thinking and practice and it structures the tests in a more intuitive way.

== Bugs Fixed ==
During testing of the '''AssignmentTeam''' model, we found two bugs, one in '''AssignmentTeam#submit_hyperlink''' and one in '''AssignmentTeam.import'''. In '''AssignmentTeam#submit_hyperlink''', '''http://''' was ''appended'' to hyperlink strings without this tag or
'''https://''' at the start of them, rather than ''prepended''. We fixed this error in our pull request. In '''AssignmentTeam.import''', '''id''', an undefined parameter, was referenced while raising an exception, and we updated it to '''assignment_id''', which was the actual name of the parameter passed to the method.

== Results ==
The model has a total of 237 lines, out of which 127 were relevant lines.
We achieved 100% coverage with avg hits per line at 2.3 (the number of times each specific line was run during the test suite)

[[File:Coverage_header.png]]
[[File:Coverage_line.png]]

== Future Work ==

DRY principle could be cleaned up a little more. Sometimes it became necessary to use the '''let''' or '''build''' helper methods in each unit test. They may all be consolidated at the beginning. 
Some more edge cases could be thought of for each method, and tests written for those. Although, we have tried to cover as many as possible. 
Additionally, in the future, the code may also be refactored with a more efficient tool. 
Test coverage through quality tests consistently added throughout the development of the Expertiza project should be the future work of the project. 

== References ==
1. [http://expertiza.ncsu.edu Expertiza] 
2. [http://wiki.expertiza.ncsu.edu/index.php/Main_Page#Expertiza Expertiza Wikipedia ] 
3. [https://github.com/expertiza/expertiza Expertiza Github Repository] 
4. [https://relishapp.com/rspec RSpec - Relish] 
5. [https://sites.google.com/site/longlastingsoftware Engineering Software as a Service]

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T20:32:08Z

Kaacken2: Change the headings.

The purpose of this project is to improve the coverage and quality of the unit tests for the assignment team model in Expertiza. This project comprised the program 3 assignment of CSC/ECE 517 in fall 2018 and is entitled "Project E1848: Writing unit tests for assignment_team.rb." The source code for this project is in [https://github.com/expertiza/expertiza/pull/1228 pull request #1228] of the [https://github.com/expertiza Expertiza project] on [https://github.com/ GitHub].

== Key Contributions ==

Out of the 30 methods defined for the model AssignmentTeam.rb, test case was written for only one. Our contribution was to successfully add test cases for all remaining 29 methods.

Hence, increasing the coverage from 5% to 100%.

== The Class under Test ==
'''AssignmentTeam''' 
This class handles all functionalities for a team linked to an assignment. Some of the functionalities include, get a list of participants in the team, get the team name, team score for the given assignment, submissions for this team (files) and (hyperlinks) and topic picked by the team. Add/or remove participants from the team. It also checks for any reviews the team may have gotten for their work. Export all teams in a CSV file, import files from CSV to form teams.

== Test Plan ==
Our test plan was to test every method individually, i.e. write unit tests. We also tested multiple cases for each method. A description of all the methods in the '''AssignmentTeam''' model in assignment_team.rb and the RSpec unit tests we wrote for them is below.

==== '''Function name: includes?(participant)''' ====
This function in assignment_team.rb checks if the '''participant''' passed as argument is a member of the team or not. For this, we utilize factorybot to build a user and a participant1 as follows-:
<pre>
let(:user1) { build(:student, id: 2) }
let(:participant1) { build(:participant, id: 1) }
</pre>

Test cases checked for are-: 
1) when the team receives a user, that user is allowed to become a team participant. The method returns '''True''' for the given participant passed as argument.

<pre>
context "when an assignment team has one participant" do
it "includes one participant" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
expect(team.includes?(participant1)).to eq true
end
end
</pre>

2) when the team receives a user with no arguments, that user is '''not''' allowed to become a team participant. The method returns '''False''' for the given participant passed as argument.

<pre>
context "when an assignment team has no users" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([])
expect(team.includes?(participant1)).to eq false
end
end
</pre>

==== Function name: parent_model ====
This function in assignment_team.rb always provides the name of the parent model which is '''Assignment'''.

Hence, the unit test also always checks if the response of this method is the string '''"Assignment"''' or not.
<pre>
it "provides the name of the parent model" do
expect(team.parent_model).to eq "Assignment"
end
</pre>

==== Function name: self.parent_model(id) ====
This function in assignment_team.rb takes in as argument id of the current '''Assignment''' for the team and returns an instance of the parent model.

Hence the unit test checks if the instance returned by this method for a given assignment id, matches the assignment or not.
<pre>
it "provides the instance of the parent model" do
allow(Assignment).to receive(:find).with(1).and_return(assignment)
expect(AssignmentTeam.parent_model(1)).to eq assignment
end
</pre>

==== Function name: fullname ====
This function in assignment_team.rb print out the name for the current class instance. for this we first build an assignment team instance and assign it the name '''"abcd"'''.

Hence the unit test checks if the assignment team has a name, and returns that same name.
<pre>
context "when the team has a name" do
it "provides the name of the class" do
team = build(:assignment_team, id: 1, name: "abcd")
expect(team.fullname).to eq "abcd"
end
end
</pre>

==== Function name: review_map_type ====
This function in assignment_team.rb always provides the name of the review map type which is '''ReviewResponseMap'''.

Hence, the unit test also always checks if the response of this method is the string '''"ReviewResponseMap"''' or not.
<pre>
it "provides the review map type" do
expect(team.review_map_type).to eq "ReviewResponseMap"
end
</pre>

==== Function name: self.prototype ====
This function in assignment_team.rb implements the prototype pattern by returning a new instance of the class '''AssignmentTeam'''.

The unit test checks if the response is a new instance of the class or not.
<pre>
it "provides the instance of the AssignmentTeam" do
expect(AssignmentTeam).to receive(:new).with(no_args)
AssignmentTeam.prototype
end
</pre>

==== Function name: assign_reviewer(reviewer) ====
This function in assignment_team.rb assigns a reviewer to the team by returning a new instance of the class '''ReviewResponseMap'''.

The unit test assigns a reviewer to the team and creates an instance of ReviewResponseMap.
<pre>
describe "#assign_reviewer" do
context "when a reviewer is present" do
it "assign the reviewer to the team" do
allow(Assignment).to receive(:find).with(team.parent_id).and_return(assignment)
allow(ReviewResponseMap).to receive(:create).
with(reviewee_id: team.id, reviewer_id: participant1.id, reviewed_object_id: assignment.id).and_return(review_response_map)
expect(team.assign_reviewer(participant1)).to eq(review_response_map)
end
end
end
</pre>

==== Function name: reviewed_by?(reviewer) ====
This function in assignment_team.rb checks if the team has been reviewed by a reviewer.

The unit test checks if the reviewer has reviewed the team. The test will find instances of ReviewResponseMaps belonging to the reviewer and the team, and will return true if such instances are present.

<pre>
describe "#reviewed_by?" do
context "when a team has a reviewer" do
it "has been reviewed by this reviewer" do
template = 'reviewee_id = ? && reviewer_id = ? && reviewed_object_id = ?'
allow(ReviewResponseMap).to receive(:where).with(template, team.id, participant1.id, team.assignment.id).and_return([review_response_map])
expect(team.reviewed_by?(participant1)).to eq true
end
end
</pre>

==== Function name: topic ====
This function in assignment_team.rb return the id of the topic picked by the team for the assignment.

The unit test first stubs a topic for the given assignment, allows a SignedUpTeam object to receive that topic and AssignmentTeam id, and return the topic id to check if it matches with the topic id of the AssignmentTeam.
<pre>
context "when the team has picked a topic" do
it "provides the topic id" do
assignment = team.assignment
allow(SignUpTopic).to receive(:find_by).with(assignment: assignment).and_return(topic)
allow(SignedUpTeam).to receive_message_chain(:find_by, :try).with(team_id: team.id).with(:topic_id).and_return(topic.id)
expect(team.topic).to eq(topic.id)
end
end
</pre>

==== Function name: has_submissions? ====
this function in assignment_team.rb is used to check if the team has submitted their work or not.

The unit test allows the team to receive submissions, by first receiving files as submission, then hyperlink as submission, and for each expects the the team's submission to be true when the function is called.
<pre>
context "when a team has submitted files" do
it "has submissions" do
allow(team).to receive_message_chain(:submitted_files, :any?).with(no_args).with(no_args).and_return(true)
end
end

context "when the team has submitted hyperlink" do
it "checks if the team has submissions" do
allow(team).to receive_message_chain(:submitted_hyperlinks, :present?).with(no_args).with(no_args).and_return(true)
end
end

after(:each) do
expect(team.has_submissions?).to be true
end
</pre>

==== Function name: participants ====
This function in assignment_team.rb returns a list of all participants in the team.

The unit test first allows the team to receive two user instances and then adds these users as participants of the team. The test then expects the function to return a list of these two users as participants of the team.
<pre>
context "when an assignment team has two participants" do
it "has those two participants" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.participants).to eq [participant1, participant2]
end
end
</pre>

The unit test first allows the team to receive a user instance but does not add this user as participant of the team. The test then expects the function to return an empty list as participants of the team.
<pre>
context "when an assignment team has a user but no participants" do
it "includes no participants" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(nil)
expect(team.participants).to eq []
end
end
</pre>

==== Function name: delete ====
This function in assignment_team.rb deletes the AssignmentTeam by destroying each participant in the team and returns an instance of AssignmentTeam.

The unit test first allows two users to be added as team participants. The test checks if the team deleted matches the current team instance.

<pre>
it "deletes the team" do
allow(team).to receive(:users).with(no_args).and_return([user1, user2])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user2.id, parent_id: team.parent_id).and_return(participant2)
expect(team.delete).to eq(team)
end
</pre>

==== Function name: destroy ====
This function in assignment_team.rb deletes all the reviews associated with the team.

The unit test will delete every instance of '''ReviewResponseMaps''' associated with the team.
<pre>
describe "#destroy" do
it "delete the reviews" do
expect(team).to receive_message_chain(:review_response_maps, :each).with(no_args).with(no_args)
team.destroy
end
end
</pre>

==== Function name: self.get_first_member(team_id) ====
This function in assignment_team.rb returns the instance of the first participant of the team for the given team id.

The unit test allows the assignment to receive a user, add it as a participant and return the first participant in the team. The test expects the function to return an instance of this participant.
<pre>
context "when team id is present" do
it "get first member of the team" do
allow(AssignmentTeam).to receive_message_chain(:find_by, :try, :try).with(id: team.id).with(:participant).with(:first).and_return(participant1)
expect(AssignmentTeam.get_first_member(team.id)).to eq(participant1)
end
end
</pre>

==== Function name: submitted_files(path = self.path) ====
This function in assignment_team.rb returns a list of files belonging to a team for a given path.

The unit test checks if the response is equal to the list of files that the team has submitted.

<pre>
describe "#submitted_files" do
context "given a path" do
it "returns submitted files" do
files = ["file1.rb"]
path = "assignment_path/5"
allow(team).to receive(:path).with(path)
allow(team).to receive(:files).with(path).and_return(files)
expect(team.submitted_files(path)).to match_array(files)
end
end
end
</pre>

==== Function name: self.import(row, assignment_id, options) ====
This function in assignment_team.rb imports a team if the team with the given id is present.

The unit test checks if the team is not imported if the team with the given id is not already present.

context "when an assignment team does not already exist with the same id" do
it "cannot be imported" do
assignment_id = 1
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(nil)
error_message = "The assignment with the id \"" + assignment_id.to_s + "\" was not found. <a href='/assignment/new'>Create</a> this assignment?"
expect { AssignmentTeam.import([], assignment_id, []) }.
to raise_error(ImportError, error_message)
end
end

The unit test checks if the team is imported if the team with the given id is already present.

context "when an assignment team with the same id already exists" do
it "gets imported through Team.import" do
row = []
assignment_id = 1
options = []
allow(Assignment).to receive(:find_by).with(id: assignment_id).and_return(assignment)
allow(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
expect(Team).to receive(:import).with(row, assignment_id, options, instance_of(AssignmentTeam))
AssignmentTeam.import(row, assignment_id, options)
end
end

==== Function name: self.export(csv, parent_id, options) ====
This function in assignment_team.rb exports an instance of class '''AssignmentTeam'''

The unit test checks if the response is a new instance of the class '''AssignmentTeam''' or not.

<pre>
describe ".export" do
it "redirects to Team.export with a new AssignmentTeam object" do
allow(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
expect(Team).to receive(:export).with([], 1, [], instance_of(AssignmentTeam))
AssignmentTeam.export([], 1, [])
end
end
</pre>

==== Function name: copy(course_id) ====
This function in assignment_team.rb copies the current assignment team and creates a new CourseTeam instance from the given team. It takes as parameter the id of the course assignment team has.

The test grabs the course id from the assignment team and calls the function to check if a course team is successfully created or not. The function returns and empty array, otherwise returns '''nil''' if the course team is not created successfully.
<pre>
context "for given assignment team" do
it "copies the assignment team to course team" do
assignment = team.assignment
course = assignment.course
expect(team.copy(course.id)).to eq([])
end
end
</pre>

==== Function name: add_participant(assignment_id, user) ====
This function in assignment_team.rb adds the user to the AssignmentTeam for the given assignment.

The unit test creates a user, and passes the user, assignment id for the team to the function and expects the result to be an instance of '''AssignmentParticipant''' meaning the user was successfully added as a participant.
<pre>
context "when a user is not a part of the team" do
it "adds the user to the team" do
user = build(:student, id: 10)
assignment = team.assignment
expect(team.add_participant(assignment.id, user)).to be_an_instance_of(AssignmentParticipant)
end
end
</pre>
 
The unit test creates a user, adds him as a participant to the team, and passes the user, assignment id for the team to the function and expects the result to be '''nil''' as the user already exists as participant of the team.
<pre>
context "when a user is already a part of the team" do
it "returns without adding user to the team" do
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
assignment = team.assignment
expect(team.add_participant(assignment.id, user1)).to eq(nil)
end
end
</pre>

==== Function name: scores(questions) ====
This function in assignment_team.rb returns the total score of the team. This function calculates scores for a given hash of questions.

The unit test checks if the response is equal to the score.

<pre>
describe "#scores" do
context "when a hash of question is given" do
it "returns the score received by the team" do
questionnaire1 = build(:questionnaire, id: 1)
questionnaire2 = build(:questionnaire, id: 2)

question1 = build(:question, id: 1, questionnaire: questionnaire1)
question2 = build(:question, id: 2, questionnaire: questionnaire2)
questions = {questionnaire1.symbol => [question1], questionnaire2.symbol => [question2]}

scores = {}
scores[:team] = team
scores[:questionnaire1] = {}
scores[:questionnaire1][:assessments] = review_response_map
scores[:questionnaire1][:scores] = 5
scores[:questionnaire2] = {}
scores[:questionnaire2][:assessments] = review_response_map
scores[:questionnaire2][:scores] = 5
scores[:total_score] = 10

allow(team.assignment).to receive(:questionnaires).with(no_args).and_return([questionnaire1, questionnaire2])
allow(ReviewResponseMap).to receive(:where).with(reviewee_id: team.id).and_return(review_response_map)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire1][:assessments], questions[:questionnaire1]).and_return(5)
allow(Answer).to receive(:compute_scores).with(scores[:questionnaire2][:assessments], questions[:questionnaire2]).and_return(5)
allow(questionnaire1).to receive(:symbol).with(no_args).and_return(:questionnaire1)
allow(questionnaire2).to receive(:symbol).with(no_args).and_return(:questionnaire2)
allow(team.assignment).to receive(:compute_total_score).with(scores.except(:total_score)).and_return(10)
expect(team.scores(questions)).to eq(scores)
end
end
end

</pre>

==== Function name: files(directory) ====
This method in assignment_team.rb successfully returns a list of files in any given directory path, not just the assignment teams directory path.

The unit test assigns the directory path as given below and checks if the list of files returned contains a specific file which is known to be in the list.
<pre>
context "when file is present in the directory" do
it "provides the list of files in directory and checks if file is present" do
directory = "spec/models"
expect(team.files(directory)).to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

The unit test assigns the directory path as given below and checks if the list of files returned does not contain a specific file which is known to not be in the list.
<pre>
context "when file is not present in the directory" do
it "provides the list of files in directory and checks if file is not present" do
directory = "spec/controllers"
expect(team.files(directory)).not_to include("spec/models/assignment_team_spec.rb")
end
end
</pre>

==== Function name: submit_hyperlink(hyperlink) ====
This function in assignment_team.rb submits the hyperlink for the team if it is valid or not empty.

The unit test checks if the hyperlink is empty and raises an error.
<pre>
context "when a hyperlink is empty" do
it "causes an exception to be raised" do
expect { team.submit_hyperlink("") }.to raise_error("The hyperlink cannot be empty!")
end
end
</pre>

The unit test checks if the hyperlink is invalid and raises a 404 error.
<pre>
context "when a hyperlink is invalid" do
it "causes an exception to be raised with the proper HTTP status code" do
invalid_hyperlink = "https://expertiza.ncsu.edu/not_a_valid_path"
allow(Net::HTTP).to receive(:get_response).and_return("404")
expect { team.submit_hyperlink(invalid_hyperlink) }.to raise_error("HTTP status code: 404")
end
end
</pre>

The unit test checks if the the hyperlink has been submitted or not.
context "when a valid hyperlink not in a certain improper format is submitted" do
it "it is fixed and is saved to the database" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu"])
allow(team).to receive(:submitted_hyperlinks=)
allow(team).to receive(:save)
allow(Net::HTTP).to receive(:get_response).and_return("0")
allow(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu", "http://www.ncsu.edu"])
team.submit_hyperlink("www.ncsu.edu ")
end
end
end
</pre>

==== Function name: remove_hyperlink(hyperlink_to_delete) ====
This function in assignment_team.rb removes the hyperlink submitted by the team.

The unit test checks if the hyperlink has been deleted or not.
describe "#remove_hyperlink" do
context "when the hyperlink is in the assignment team's hyperlinks" do
it "is removed from the team's list of hyperlinks" do
allow(team).to receive(:hyperlinks).and_return(["https://expertiza.ncsu.edu", "https://www.ncsu.edu"])
expect(team).to receive(:submitted_hyperlinks=)
expect(team).to receive(:save)
expect(YAML).to receive(:dump).with(["https://expertiza.ncsu.edu"])
team.remove_hyperlink("https://www.ncsu.edu")
end
end
end

==== Function name: self.team(participant) ====
This function in assignment_team.rb returns the AssingmentTeam object that the given participant belongs to.

The unit test first builds a user and assigns that user as a participant1 of the team. Then allows that participant to be added as a team user and finally search the team for the given team user and expect the team for participant1 to be equal to the AssignmentTeam.
<pre>
context "when there is a participant" do
it "provides the team for participant" do
teamuser = build(:team_user, id: 1, team_id: team.id, user_id: user1.id)
allow(team).to receive(:users).with(no_args).and_return([user1])
allow(AssignmentParticipant).to receive(:find_by).with(user_id: user1.id, parent_id: team.parent_id).and_return(participant1)
allow(TeamsUser).to receive(:where).with(user_id: participant1.user_id).and_return([teamuser])
allow(Team).to receive(:find).with(teamuser.team_id).and_return(team)
expect(AssignmentTeam.team(participant1)).to eq(team)
end
end
</pre>

==== Function name: self.export_fields(options) ====
This function in assignment_team.rb exports the fields for a given set of options. It always returns a list containing ["Team Name", "Assignment Name"] if the given set of options have a team name set to true.

The unit test expects the method to return a static list of strings for the team passed as options, with the team having a name.
<pre>
context "when team has name" do
it "exports the fields" do
expect(AssignmentTeam.export_fields(team)).to eq(["Team Name", "Assignment Name"])
end
end
</pre>

==== Function name: self.remove_team_by_id(id) ====
This function in assignment_team.rb removes team by using its id.

The unit test deletes the team by using its id and checks if return value is the instance of class '''AssignmentTeam'''.

<pre>
describe ".remove_team_by_id" do
context "when a team has an id" do
it "delete the team by id" do
allow(AssignmentTeam).to receive(:find).with(team.id).and_return(team)
expect(AssignmentTeam.remove_team_by_id(team.id)).to eq(team)
end
end
end
</pre>

==== Function name: path ====
This function in assignment_team.rb returns a path to the directory where the team has submitted their files.

The unit test checks if the response is equal to the path belonging to the team's submission.
<pre>
describe "#path" do
it "returns the path" do
allow(team).to receive_message_chain(:assignment, :path).and_return("assignment_path")
allow(team).to receive(:directory_num).and_return(5)
expect(team.path).to eq "assignment_path/5"
end
end
</pre>

==== Function name: set_student_directory_num ====
This function in assignment_team.rb sets the directory number for the team.

The unit test checks if the directory number for the team has been set. The test will check if the return value is equal to true.

<pre>
describe "#set_student_directory_num" do
it "sets the directory for the team" do
team = build(:assignment_team, id: 1, parent_id: 1, directory_num: -1)
max_num = 0
allow(AssignmentTeam).to receive_message_chain(:where, :order, :first, :directory_num).
with(parent_id: team.parent_id).with(:directory_num, :desc).with(no_args).with(no_args).and_return(max_num)
expect(team.set_student_directory_num).to be true
end
end
</pre>

==== Function name: received_any_peer_review? ====
This function in assignment_team.rb checks if the team has received any peer reviews.

The unit test checks if any instance of '''ReviewResponseMap''' is present for the team.

<pre>
describe "#received_any_peer_review?" do
it "checks if the team has received any reviews" do
allow(ResponseMap).to receive_message_chain(:where, :any?).with(reviewee_id: team.id, reviewed_object_id: team.parent_id).with(no_args).and_return(true)
expect(team.received_any_peer_review?).to be true
end
end
</pre>

== Test Design ==
=== Test Structure ===
=== Stubs for Isolating the UUT ===
In order to isolate the unit under test (UUT), i.e. the current method under test, we employed RSpec stubs. We stubbed out database calls and methods that triggered them in order to improve the run time of the unit tests, and we also stubbed out some outgoing command and query messages in order to test only the current method under test.

=== DRY Testing Practices ===
We exploited factories and the RSpec helper method '''let''' as well as '''context''' blocks to make our unit tests shorter, more readable, and more maintainable, or, in essence, DRYer.

==== Factories and the let RSPEC Helper Method ====
Using the FactoryBot factories in '''factories.rb''' allowed us to use real Expertiza objects in our unit tests. We used the '''FactoryBot.build''' method to make our objects in order to avoid the run time penalty of saving (and this later having to retrieve) objects from the database. We used the '''let''' method with the factory as in the example below to make lazy-allocated objects which are cached throughout each example, improving run time.

<pre>let(:team) { build(:assignment_team, id: 1, parent_id: 1) }</pre>

Whenever '''team''' is called in an example, it returns the same value, i.e. the same object, which essentially allows tests that need it to have access to the same object without the need for allocating it as a class variable or instance variable for all of the tests or some of the tests. We placed these statements outside the scope of our unit test examples so the same objects could be used throughout all of them, DRYing out the test code.

== Testing Framework ==

=== RSpec Introduction ===
[http://rspec.info/ RSPEC] is a testing framework for Ruby for behavior-driven development (BDD) licensed under MIT. It is inspired by JBehave and contains fully integrated JMock based framework which has a very rich and powerful DSL (domain-specific language) which resembles a natural language specification. Composed of multiple libraries structured to work together, RSpec provides encapsulated testing via the describe block to specify the behavior of the class and the context for the unit test case.

=== Why RSpec? ===
RSpec is easy to learn and implement and can be used with other testing tools like Cucumber and Minitest independently. It is extremely powerful for testing states with complicated setup and also helps in tearing down complex code to access the objects required for testing RSpec semantics encourage agile thinking and practice and it structures the tests in a more intuitive way.

== Bugs Fixed ==
During testing of the '''AssignmentTeam''' model, we found two bugs, one in '''AssignmentTeam#submit_hyperlink''' and one in '''AssignmentTeam.import'''. In '''AssignmentTeam#submit_hyperlink''', '''http://''' was ''appended'' to hyperlink strings without this tag or
'''https://''' at the start of them, rather than ''prepended''. We fixed this error in our pull request. In '''AssignmentTeam.import''', '''id''', an undefined parameter, was referenced while raising an exception, and we updated it to '''assignment_id''', which was the actual name of the parameter passed to the method.

== Results ==
The model has a total of 237 lines, out of which 127 were relevant lines.
We achieved 100% coverage with avg hits per line at 2.3 (the number of times each specific line was run during the test suite)

[[File:Coverage_header.png]]
[[File:Coverage_line.png]]

== Future Work ==

DRY principle could be cleaned up a little more. Sometimes it became necessary to use the '''let''' or '''build''' helper methods in each unit test. They may all be consolidated at the beginning. 
Some more edge cases could be thought of for each method, and tests written for those. Although, we have tried to cover as many as possible. 
Additionally, in the future, the code may also be refactored with a more efficient tool. 
Test coverage through quality tests consistently added throughout the development of the Expertiza project should be the future work of the project. 

== References ==
1. [http://expertiza.ncsu.edu Expertiza] 
2. [http://wiki.expertiza.ncsu.edu/index.php/Main_Page#Expertiza Expertiza Wikipedia ] 
3. [https://github.com/expertiza/expertiza Expertiza Github Repository] 
4. [https://relishapp.com/rspec RSpec - Relish] 
5. [https://sites.google.com/site/longlastingsoftware Engineering Software as a Service]

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T15:27:15Z

Kaacken2: /* DRY Testing Practices */ Add section summary and factories and let method info.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T14:52:49Z

Kaacken2: /* Stubs for Isolating the UUT */ Fill in the section.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T14:44:16Z

Kaacken2: /* Bugs Detected */

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T14:43:21Z

Kaacken2: Fill in the bugs detected section.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T14:20:00Z

Kaacken2: Add material to the bugs detected section.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T01:27:05Z

Kaacken2:

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-11-02T01:24:56Z

Kaacken2: Change the headings.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-10-31T21:32:59Z

Kaacken2: Edit the headings.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-10-31T21:17:02Z

Kaacken2: Fix some headings.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-10-31T21:16:43Z

Kaacken2: Add some headings.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-10-31T18:55:00Z

Kaacken2: Add an introduction.

CSC/ECE 517 Fall 2018- Project E1848: Writing unit tests for assignment team.rb

2018-10-31T18:33:06Z

Kaacken2: Add a summary.

The purpose of this project is to improve the coverage and quality of the unit tests for the assignment team model in Expertiza.