Expertiza_Wiki - User contributions [en]

E1875 Revision Planning Tool

2018-12-14T13:36:51Z

Mfleader: /* Files modified */

== What's it about? ==
In the first round of Expertiza reviews, we ask reviewers to give authors some guidance on how to improve their work. Then in the second round, reviewers rate how well authors have followed their suggestions. We could carry the interaction one step further if we asked authors to make up a revision plan based on the first-round reviews. That is, authors would say what they were planning to do to improve their work. Then second-round reviewers would assess how well they did it. In essence, this means that authors would be adding criteria to the second-round rubric that applied only to their submission. We are interested in having this implemented and used in a class so that we can study its effect.

 
== What needs to be done? ==
* Develop UI for authors to create new questions to add to the second round-rubric. This should be a form that includes the following:
** A description of the revision plan. Eg: We will add feature X to address issues a,b and c. We will modify feature Y and expect it to resolve errors d, c and e.
** One or more questions for every proposed improvement. Example:
*** How effectively did feature X address / solve issues a, b and c?
*** Did modification of feature Y resolve error d?
* Every new question must be linked to the second-round questionnaire.
* Every new question must be linked to the author’s submission

 
== Problem Statement ==
In the 2nd round of reviews, the Author should be able to add a statement to direct towards Author selected improvements from Round 1 to Round 2.

 
== Motivation ==
The OSS and Final projects are different for every team. From a reviewers perspective, not all questions make sense for all projects. The motivation behind this project is:
* Questions unique to each project gives the reviewers a perspective on the author’s objectives.
* Allow the Author to get feedback on whether or not they accomplished their self-directed goal.

 
== Criteria for completion ==
# Direct user to Revision Improvement Questionnaire.
# Create a form for a Assignment Team to add Questions to a Questionnaire that are specific to that Submission.
# Append Revision Improvement Questionnaire to 2nd Round Review Questionnaire.

 

=== UI mockups ===
The first image shows a mockup of what the Author will see on the submission page to submit new additional questions for review. 
[[File:E1875U1_1.jpg]] 
Second is a view of what the reviewer will see. It should blend in with the review questions submitted by the instructor for all similar projects. 
[[File:E1875UI_2.jpg]]
 
 

== Files modified ==

==== Controllers ====
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-a7ee7dddd7aedbc0b814d98f0cb34c25 grades_controller.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-b41fa84d1ee0c03c4e301f977fbe453d questionnaires_controller.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-7786ab741930f6bace28b7e5da61b8d6 response_controller.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-33d668958529875af7029d78e37aff60 submitted_content_controller.rb]

==== Views ====
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-2213cf9074761b4121a9fb3ddcce6145 questionnaires/_questionnaire.html.erb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-6b83ba9473bd5cc58d3b7c620235a6c0 submitted_content/edit.html.erb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-6b83ba9473bd5cc58d3b7c620235a6c0 submitted_content/edit.html.erb]

==== Models ====
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-a983bfc492e6d1982c673bc208afe459 answer.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-3dffd0131e1a14847e8c98376bae4984 questionnaire.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-f2caf2e29f94ec94cb27bdb86ec85d40 response.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-85f51952994f8162980c605efd60db44 revision_review_questionnaire.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-c6f2a3b3452f5a9effa4a2b023ed2322 submission_record.rb]

==== Database ====
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-c2ba560985d8d1ea9184e04d71bf2c83 20181123004154_add_submission_record_to_questionnaire.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-1acd2e7e27a227829d5d14a91c863bb6 schema.rb]

==== Specs ====
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-ebb9ab8d49abf2b40d4aad426dad68e5 grades_controller_spec.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-df286dc963f50de24c47bacfb0b3a143 questionnaires_controller_spec.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-3a17ddf9d828caa60f11423f20fb88a9 factories.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-7d95010cdfe370a461e216ba1d724392 assignment_submission_spec.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-a68a7982922073b9602c0fd6097e0bd2 answer_spec.rb]
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-e162432910d3b3b29b3c9711d6e818bb revision_review_questionnaire_spec.rb]

==== config ====
* [https://github.com/expertiza/expertiza/pull/1302/files#diff-21497849d8f00507c9c8dcaf6288b136 routes.rb]

== Test Plan and Demo ==

=== Test Plan ===
# Login as 'instructor6' with password 'password'.
# Create 2 new users named 'abc' and 'xyz'.
# Make an assignment with the name 'RPT'. Add abc and xyz as participants to RPT.
# Set 2 rounds of submissions and reviews in RPT.
# impersonate abc.
# submit for round 1.
# move to round 1 review stage.
# impersonate xyz.
# add review as xyz.
# move to round 2 submission stage
# impersonate abc.
# submit a revision plan through the submission page.
# move to round 2 review.
# impersonate xyz.
# verify that revision plan wuestions are added to the review and submit the review.
# impersonate abc.
# verify that review has been received on the revision plan questions.

=== demo video ===
[https://www.youtube.com/watch?v=J1QeUd0b7RQ E1875]

E1875 Revision Planning Tool

2018-12-13T22:49:52Z

Mfleader: /* Files to be modified */

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T04:50:11Z

Mfleader: /* Testing Implementation */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

To describe VMQuestionResponse

1) Test initialize

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with any other questionnaire type

2) Test add questions

* in the context when VMQuestionResponse is given a list of questions

3) Test add_reviews

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with a author feedback questionnaire

* in the context when VMQuestionResponse is initialized with a teammate review questionnaire

* in the context when VMQuestionResponse is initialized with a metareview questionnaire

4) Test display_team_members

5) Test add_team_members

6) Test listofteamparticipants

7) Test max_score_for_questionnaire

8) Test add_answer

9) Test get_number_of_comments_greater_than_10_words

== Testing Implementation ==

*''initialize'' : This tests that the VmQuestionResponse is initialized with the appropriate round number.
<pre>
describe '#initialize' do
context 'when intitialized with a review questionnaire' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'initializes the instance variables' do
expect(response.round).to eq 1
expect(response.questionnaire_type).to eq "ReviewQuestionnaire"
expect(response.rounds).to eq 2
end
end
context 'when intitialized with any other questionnaire type' do
let(:response) { VmQuestionResponse.new(metareview_questionnaire, assignment, 1) }
it 'initializes the instance variables' do
expect(response.round).to eq 1
expect(response.questionnaire_type).to eq "MetareviewQuestionnaire"
expect(response.rounds).to eq 2
end
end
end
</pre>

*''add_questions'': This tests that the VmQuestionResponse adds questions from a given review
<pre>
describe '#add_questions' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'adds questions' do
response.add_questions questions
expect(response.max_score).to eq 5
expect(response.list_of_rows.size).to eq 1
expect(response.max_score_for_questionnaire()).to eq questions.size * review_questionnaire.max_question_score
end
end
</pre>

*''add_reviews'' : This tests that the VmQuestionResponse adds reviews and reviewers from a given review
<pre>
describe '#add_reviews' do
context 'when initialized with a review questionnaire' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a author feedback questionnaire' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a teammate review questionnaire' do
let(:response) { VmQuestionResponse.new(teammate_review_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a meta review type' do
let(:response) { VmQuestionResponse.new(metareview_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(MetareviewResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
end
</pre>

*''display_team_members'' : This tests that the VmQuestionResponse can print out the appropriate team member names.
<pre>
describe '#display_team_members' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'displays the members of the team' do
team = double('team')
participant2 = double('participant2')
allow(participant2).to receive_messages :fullname => 'R'
team_member_names = [participant0, participant1, participant2]
allow(team).to receive_messages(:participants => team_member_names)
out = 'Team members:'
response.add_team_members(team)
team.participants.each do |participant|
out = out + " (" + participant.fullname + ") "
end
expect(response.display_team_members).to eq out
end
end
</pre>

*''add_answer'' : This tests that the VmQuestionResponse adds all of the review scores from its reviews to VmQuestionResponseCells in VmQuestionResponseRows.
<pre>
describe '#add_answer' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1 ) }
let(:tag_dep) do
tag_dep = double('tag_dep')
allow(tag_dep).to receive_messages(:question_type => question.type,
:answer_length_threshold => 4,
:tag_prompt_id => 1)
tag_dep
end
it 'adds an answer' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
allow(Answer).to receive_messages(:where => [answer])
allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])
allow(Question).to receive_messages(:find => question)
allow(TagPrompt).to receive_messages(:find => true)
allow(VmTagPromptAnswer).to receive_messages(:new => '')
allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

response.add_questions questions
response.add_reviews(participant0, '', false)
end
end
</pre>

*''get_number_of_comments_greater_than_10_words'' : This tests that VmQuestionResponse only finds comments that have at least 10 words.
<pre>
describe '#get_number_of_comments_greater_than_10_words' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1 ) }
let(:tag_dep) do
tag_dep = double('tag_dep')
allow(tag_dep).to receive_messages(:question_type => question.type,
:answer_length_threshold => 4,
:tag_prompt_id => 1)
tag_dep
end
it 'returns number of comments greater than 10 words' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
allow(Answer).to receive_messages(:where => [answer])
allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])
allow(Question).to receive_messages(:find => question)
allow(TagPrompt).to receive_messages(:find => true)
allow(VmTagPromptAnswer).to receive_messages(:new => '')
allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')
allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,
:question_max_score => 5, :score_row => [3])
allow(VmQuestionResponseRow).to receive_messages(:new => row)

response.add_questions questions
response.add_reviews(participant0, '', false)
expect(response.list_of_rows.size).to eq 1
response.get_number_of_comments_greater_than_10_words
expect(response.list_of_rows[0].countofcomments).to eq 7
end
end
</pre>

== Results ==

We have now attained 97.25% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

[https://youtu.be/yDfhSqVOoOk Testing Video(YouTube)]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T04:49:43Z

Mfleader: /* Testing Implementation */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

To describe VMQuestionResponse

1) Test initialize

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with any other questionnaire type

2) Test add questions

* in the context when VMQuestionResponse is given a list of questions

3) Test add_reviews

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with a author feedback questionnaire

* in the context when VMQuestionResponse is initialized with a teammate review questionnaire

* in the context when VMQuestionResponse is initialized with a metareview questionnaire

4) Test display_team_members

5) Test add_team_members

6) Test listofteamparticipants

7) Test max_score_for_questionnaire

8) Test add_answer

9) Test get_number_of_comments_greater_than_10_words

== Testing Implementation ==

*''initialize'' : This tests that the VmQuestionResponse is initialized with the appropriate round number.
<pre>
describe '#initialize' do
context 'when intitialized with a review questionnaire' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'initializes the instance variables' do
expect(response.round).to eq 1
expect(response.questionnaire_type).to eq "ReviewQuestionnaire"
expect(response.rounds).to eq 2
end
end
context 'when intitialized with any other questionnaire type' do
let(:response) { VmQuestionResponse.new(metareview_questionnaire, assignment, 1) }
it 'initializes the instance variables' do
expect(response.round).to eq 1
expect(response.questionnaire_type).to eq "MetareviewQuestionnaire"
expect(response.rounds).to eq 2
end
end
end
</pre>

*''add_questions'': This tests that the VmQuestionResponse adds questions from a given review
<pre>
describe '#add_questions' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'adds questions' do
response.add_questions questions
expect(response.max_score).to eq 5
expect(response.list_of_rows.size).to eq 1
expect(response.max_score_for_questionnaire()).to eq questions.size * review_questionnaire.max_question_score
end
end
</pre>

*''add_reviews'' : This tests that the VmQuestionResponse adds reviews and reviewers from a given review
<pre>
describe '#add_reviews' do
context 'when initialized with a review questionnaire' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a author feedback questionnaire' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a teammate review questionnaire' do
let(:response) { VmQuestionResponse.new(teammate_review_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a meta review type' do
let(:response) { VmQuestionResponse.new(metareview_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(MetareviewResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
end
</pre>

*''display_team_members'' : This tests that the VmQuestionResponse can print out the appropriate team member names.
<pre>
describe '#display_team_members' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'displays the members of the team' do
team = double('team')
participant2 = double('participant2')
allow(participant2).to receive_messages :fullname => 'R'
team_member_names = [participant0, participant1, participant2]
allow(team).to receive_messages(:participants => team_member_names)
out = 'Team members:'
response.add_team_members(team)
team.participants.each do |participant|
out = out + " (" + participant.fullname + ") "
end
expect(response.display_team_members).to eq out
end
end
</pre>

*''add_answer'' : This tests that the VmQuestionResponse adds all of the review scores from its reviews to VmQuestionResponseCells
in VmQuestionResponseRows.
<pre>
describe '#add_answer' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1 ) }
let(:tag_dep) do
tag_dep = double('tag_dep')
allow(tag_dep).to receive_messages(:question_type => question.type,
:answer_length_threshold => 4,
:tag_prompt_id => 1)
tag_dep
end
it 'adds an answer' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
allow(Answer).to receive_messages(:where => [answer])
allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])
allow(Question).to receive_messages(:find => question)
allow(TagPrompt).to receive_messages(:find => true)
allow(VmTagPromptAnswer).to receive_messages(:new => '')
allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

response.add_questions questions
response.add_reviews(participant0, '', false)
end
end
</pre>

*''get_number_of_comments_greater_than_10_words'' : This tests that VmQuestionResponse only finds comments that have at least 10 words.
<pre>
describe '#get_number_of_comments_greater_than_10_words' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1 ) }
let(:tag_dep) do
tag_dep = double('tag_dep')
allow(tag_dep).to receive_messages(:question_type => question.type,
:answer_length_threshold => 4,
:tag_prompt_id => 1)
tag_dep
end
it 'returns number of comments greater than 10 words' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
allow(Answer).to receive_messages(:where => [answer])
allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])
allow(Question).to receive_messages(:find => question)
allow(TagPrompt).to receive_messages(:find => true)
allow(VmTagPromptAnswer).to receive_messages(:new => '')
allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')
allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,
:question_max_score => 5, :score_row => [3])
allow(VmQuestionResponseRow).to receive_messages(:new => row)

response.add_questions questions
response.add_reviews(participant0, '', false)
expect(response.list_of_rows.size).to eq 1
response.get_number_of_comments_greater_than_10_words
expect(response.list_of_rows[0].countofcomments).to eq 7
end
end
</pre>

== Results ==

We have now attained 97.25% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

[https://youtu.be/yDfhSqVOoOk Testing Video(YouTube)]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T04:49:26Z

Mfleader: /* Testing Implementation */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

To describe VMQuestionResponse

1) Test initialize

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with any other questionnaire type

2) Test add questions

* in the context when VMQuestionResponse is given a list of questions

3) Test add_reviews

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with a author feedback questionnaire

* in the context when VMQuestionResponse is initialized with a teammate review questionnaire

* in the context when VMQuestionResponse is initialized with a metareview questionnaire

4) Test display_team_members

5) Test add_team_members

6) Test listofteamparticipants

7) Test max_score_for_questionnaire

8) Test add_answer

9) Test get_number_of_comments_greater_than_10_words

== Testing Implementation ==

*''initialize'' : This tests that the VmQuestionResponse is initialized with the appropriate round number.
<pre>
describe '#initialize' do
context 'when intitialized with a review questionnaire' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'initializes the instance variables' do
expect(response.round).to eq 1
expect(response.questionnaire_type).to eq "ReviewQuestionnaire"
expect(response.rounds).to eq 2
end
end
context 'when intitialized with any other questionnaire type' do
let(:response) { VmQuestionResponse.new(metareview_questionnaire, assignment, 1) }
it 'initializes the instance variables' do
expect(response.round).to eq 1
expect(response.questionnaire_type).to eq "MetareviewQuestionnaire"
expect(response.rounds).to eq 2
end
end
end
</pre>

*''add_questions'': This tests that the VmQuestionResponse adds questions from a given review
<pre>
describe '#add_questions' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'adds questions' do
response.add_questions questions
expect(response.max_score).to eq 5
expect(response.list_of_rows.size).to eq 1
expect(response.max_score_for_questionnaire()).to eq questions.size * review_questionnaire.max_question_score
end
end
</pre>

*''add_reviews'' : This tests that the VmQuestionResponse adds reviews and reviewers from a given review
<pre>
describe '#add_reviews' do
context 'when initialized with a review questionnaire' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a author feedback questionnaire' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a teammate review questionnaire' do
let(:response) { VmQuestionResponse.new(teammate_review_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
context 'when initialized with a meta review type' do
let(:response) { VmQuestionResponse.new(metareview_questionnaire, assignment, 1) }
it 'adds reviews' do
allow(MetareviewResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
response.add_reviews(participant0, team, false)
expect(response.list_of_reviews.size).to eq 1
expect(response.list_of_reviewers.size).to eq 1
expect(response.list_of_reviews).to eq [review]
end
end
end
</pre>

*''display_team_members'' : This tests that the VmQuestionResponse can print out the appropriate team member names.
<pre>
describe '#display_team_members' do
let(:response) { VmQuestionResponse.new(review_questionnaire, assignment, 1) }
it 'displays the members of the team' do
team = double('team')
participant2 = double('participant2')
allow(participant2).to receive_messages :fullname => 'R'
team_member_names = [participant0, participant1, participant2]
allow(team).to receive_messages(:participants => team_member_names)
out = 'Team members:'
response.add_team_members(team)
team.participants.each do |participant|
out = out + " (" + participant.fullname + ") "
end
expect(response.display_team_members).to eq out
end
end
</pre>

*''add_answers'' : This tests that the VmQuestionResponse adds all of the review scores from its reviews to VmQuestionResponseCells
in VmQuestionResponseRows.
<pre>
describe '#add_answer' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1 ) }
let(:tag_dep) do
tag_dep = double('tag_dep')
allow(tag_dep).to receive_messages(:question_type => question.type,
:answer_length_threshold => 4,
:tag_prompt_id => 1)
tag_dep
end
it 'adds an answer' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
allow(Answer).to receive_messages(:where => [answer])
allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])
allow(Question).to receive_messages(:find => question)
allow(TagPrompt).to receive_messages(:find => true)
allow(VmTagPromptAnswer).to receive_messages(:new => '')
allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

response.add_questions questions
response.add_reviews(participant0, '', false)
end
end
</pre>

*''get_number_of_comments_greater_than_10_words'' : This tests that VmQuestionResponse only finds comments that have at least 10 words.
<pre>
describe '#get_number_of_comments_greater_than_10_words' do
let(:response) { VmQuestionResponse.new(author_feedback_questionnaire, assignment, 1 ) }
let(:tag_dep) do
tag_dep = double('tag_dep')
allow(tag_dep).to receive_messages(:question_type => question.type,
:answer_length_threshold => 4,
:tag_prompt_id => 1)
tag_dep
end
it 'returns number of comments greater than 10 words' do
allow(FeedbackResponseMap).to receive_messages(:where => mapping)
allow(Participant).to receive_messages(:find => participant1)
allow(Answer).to receive_messages(:where => [answer])
allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])
allow(Question).to receive_messages(:find => question)
allow(TagPrompt).to receive_messages(:find => true)
allow(VmTagPromptAnswer).to receive_messages(:new => '')
allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')
allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,
:question_max_score => 5, :score_row => [3])
allow(VmQuestionResponseRow).to receive_messages(:new => row)

response.add_questions questions
response.add_reviews(participant0, '', false)
expect(response.list_of_rows.size).to eq 1
response.get_number_of_comments_greater_than_10_words
expect(response.list_of_rows[0].countofcomments).to eq 7
end
end
</pre>

== Results ==

We have now attained 97.25% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

[https://youtu.be/yDfhSqVOoOk Testing Video(YouTube)]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T04:37:11Z

Mfleader: /* Testing Implementation */

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T04:01:13Z

Mfleader: /* Testing Strategy: Unit Test */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

To describe VMQuestionResponse

1) Test initialize

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with any other questionnaire type

2) Test add questions

* in the context when VMQuestionResponse is given a list of questions

3) Test add_reviews

* in the context when VMQuestionResponse is initialized with a review questionnaire

* in the context when VMQuestionResponse is initialized with a author feedback questionnaire

* in the context when VMQuestionResponse is initialized with a teammate review questionnaire

* in the context when VMQuestionResponse is initialized with a metareview questionnaire

4) Test display_team_members

5) Test add_team_members

6) Test listofteamparticipants

7) Test max_score_for_questionnaire

8) Test add_answer

9) Test get_number_of_comments_greater_than_10_words

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T03:57:55Z

Mfleader: /* Testing Strategy: Unit Test */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

To describe VMQuestionResponse

1) Test initialize

1.1) in the context when VMQuestionResponse is initialized with a review questionnaire

1.2) in the context when VMQuestionResponse is initialized with any other questionnaire type

2) Test add questions

2.1) in the context when VMQuestionResponse is given a list of questions

3) Test add_reviews

3.1) in the context when VMQuestionResponse is initialized with a review questionnaire

3.2) in the context when VMQuestionResponse is initialized with a author feedback questionnaire

3.3) in the context when VMQuestionResponse is initialized with a teammate review questionnaire

3.4) in the context when VMQuestionResponse is initialized with a metareview questionnaire

4) Test display_team_members

5) Test add_team_members

6) Test listofteamparticipants

7) Test max_score_for_questionnaire

8) Test add_answer

9) Test get_number_of_comments_greater_than_10_words

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T03:56:42Z

Mfleader: /* Testing Strategy: Unit Test */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

To describe VMQuestionResponse

1) Test initialize

1.1) in the context when VMQuestionResponse is initialized with a review questionnaire

1.2) in the context when VMQuestionResponse is initialized with any other questionnaire type

2) Test add questions

2.1) in the context when VMQuestionResponse is given a list of questions

3) Test add_reviews

3.1) in the context when VMQuestionResponse is initialized with a review questionnaire

3.2) in the context when VMQuestionResponse is initialized with a author feedback questionnaire

3.3) in the context when VMQuestionResponse is initialized with a teammate review questionnaire

3.4) in the context when VMQuestionResponse is initialized with a metareview questionnaire

4) Test display_team_members

5) Test add_team_members

6) Test listofteamparticipants

7) Test max_score_for_questionnaire

8) Test add_answer

9) Test get_number_of_comments_greater_than_10_words

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T03:53:16Z

Mfleader:

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

To describe VMQuestionResponse

1) Test initialize
1.1) in the context when VMQuestionResponse is initialized with a review questionnaire
1.2) in the context when VMQuestionResponse is initialized with any other questionnaire type
2) Test add questions
2.1) in the context when VMQuestionResponse is given a list of questions
3) Test add_reviews
3.1) in the context when VMQuestionResponse is initialized with a review questionnaire
3.2) in the context when VMQuestionResponse is initialized with a author feedback questionnaire
3.3) in the context when VMQuestionResponse is initialized with a teammate review questionnaire
3.4) in the context when VMQuestionResponse is initialized with a metareview questionnaire
4) Test display_team_members
5) Test add_team_members
6) Test listofteamparticipants
7) Test max_score_for_questionnaire
8) Test add_answer
9) Test get_number_of_comments_greater_than_10_words

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T02:08:39Z

Mfleader: /* Problem Statement */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Objective ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

describe VMQuestionResponse do

context 'when initialized with a valid assignment questionnaire'

it 'adds reviews'

context 'when given a team'

it 'displays the members of the team'

context 'when given a list of valid questions'

it 'can calculate the max score for the questionnaire'

it 'has the round value of the given questionnaire'

context 'is initialized with an AuthorFeedbackQuestionnaire'

it 'adds reviews'

it 'adds answers'

it 'get the number of comments greater than 10 words'

context 'is initialized with a TeammateReviewQuestionnair'

it 'adds reviews'

context 'is initialized with a MetaReviewQuesionnaire'

it 'adds reviews'

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T02:06:55Z

Mfleader: /* Testing Plan */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Problem Statement ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Strategy: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

describe VMQuestionResponse do

context 'when initialized with a valid assignment questionnaire'

it 'adds reviews'

context 'when given a team'

it 'displays the members of the team'

context 'when given a list of valid questions'

it 'can calculate the max score for the questionnaire'

it 'has the round value of the given questionnaire'

context 'is initialized with an AuthorFeedbackQuestionnaire'

it 'adds reviews'

it 'adds answers'

it 'get the number of comments greater than 10 words'

context 'is initialized with a TeammateReviewQuestionnair'

it 'adds reviews'

context 'is initialized with a MetaReviewQuesionnaire'

it 'adds reviews'

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T02:02:29Z

Mfleader:

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

== Problem Statement ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

=== Testing Style: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

describe VMQuestionResponse do

context 'when initialized with a valid assignment questionnaire'

it 'adds reviews'

context 'when given a team'

it 'displays the members of the team'

context 'when given a list of valid questions'

it 'can calculate the max score for the questionnaire'

it 'has the round value of the given questionnaire'

context 'is initialized with an AuthorFeedbackQuestionnaire'

it 'adds reviews'

it 'adds answers'

it 'get the number of comments greater than 10 words'

context 'is initialized with a TeammateReviewQuestionnair'

it 'adds reviews'

context 'is initialized with a MetaReviewQuesionnaire'

it 'adds reviews'

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T01:37:31Z

Mfleader:

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

=== Testing Style: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

== Problem Statement ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests to attain at least 90% coverage by line.

=== Team ===

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

=== Files Involved ===

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

describe VMQuestionResponse do

context 'when initialized with a valid assignment questionnaire'

it 'adds reviews'

context 'when given a team'

it 'displays the members of the team'

context 'when given a list of valid questions'

it 'can calculate the max score for the questionnaire'

it 'has the round value of the given questionnaire'

context 'is initialized with an AuthorFeedbackQuestionnaire'

it 'adds reviews'

it 'adds answers'

it 'get the number of comments greater than 10 words'

context 'is initialized with a TeammateReviewQuestionnair'

it 'adds reviews'

context 'is initialized with a MetaReviewQuesionnaire'

it 'adds reviews'

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T01:33:17Z

Mfleader: /* Introduction */

== Introduction ==

=== VMQuestionResponse in Brief ===
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

=== Testing Style: Unit Test ===
Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

== Problem Statement ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests for this model with a coverage of at least 90%.

'''Team'''

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

'''Files Involved'''

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

describe VMQuestionResponse do

context 'when initialized with a valid assignment questionnaire'

it 'adds reviews'

context 'when given a team'

it 'displays the members of the team'

context 'when given a list of valid questions'

it 'can calculate the max score for the questionnaire'

it 'has the round value of the given questionnaire'

context 'is initialized with an AuthorFeedbackQuestionnaire'

it 'adds reviews'

it 'adds answers'

it 'get the number of comments greater than 10 words'

context 'is initialized with a TeammateReviewQuestionnair'

it 'adds reviews'

context 'is initialized with a MetaReviewQuesionnaire'

it 'adds reviews'

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

CSC/ECE 517 Fall 2018/E1849 Write Unit Tests for vm question response.rb

2018-11-10T01:31:44Z

Mfleader:

== Introduction ==

'''VMQuestionResponse in Brief'''
This class acquires reviews from a given questionnaire and assignment, and creates a heat map visualization of the review scores a reviewee received from other people (reviewers) for an assignment.

'''Testing Style: Unit Test'''

Testing VMQuestionResponse hinges upon collaboration verification, so that we know VMQuestionResponse is getting the right messages from the right classes, so that it can appropriately create its data structures.

== Problem Statement ==

There are currently no test cases for vm_question_response.rb. We seek to create unit tests for this model with a coverage of at least 90%.

'''Team'''

Matt Leader (mfleader@ncsu.edu)

Jonathan Gill (jtgill@ncsu.edu)

'''Files Involved'''

app/models/vm_question_response.rb

spec/models/vm_question_response_spec.rb

== Testing Plan ==

We first went through each method of the VMQuestionResponse class and determined whether the method was a command, or query and whether the method was incoming, outgoing, or sent-to-self. For each method we will write tests for valid and invalid inputs as well as edge cases.

Here is an outline of our implementation strategy:

describe VMQuestionResponse do

context 'when initialized with a valid assignment questionnaire'

it 'adds reviews'

context 'when given a team'

it 'displays the members of the team'

context 'when given a list of valid questions'

it 'can calculate the max score for the questionnaire'

it 'has the round value of the given questionnaire'

context 'is initialized with an AuthorFeedbackQuestionnaire'

it 'adds reviews'

it 'adds answers'

it 'get the number of comments greater than 10 words'

context 'is initialized with a TeammateReviewQuestionnair'

it 'adds reviews'

context 'is initialized with a MetaReviewQuesionnaire'

it 'adds reviews'

== Testing Implementation ==

it 'adds reviews' do

allow(ReviewResponseMap).to receive_messages(:get_assessments_for => [review], :find => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_reviews(ppnt0, team, false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

This code tests that the add_reviews method works when VMQuestionResponse has been initialized with @questionnaire_type = "ReviewQuestionnaire"

context 'when given a team' do

it 'displays the members of the team' do

team = double('team')

ppnt2 = double('ppnt2')

allow(ppnt2).to receive_messages :fullname => 'R'

team_member_names = [ppnt0, ppnt1, ppnt2]

allow(team).to receive_messages(:participants => team_member_names)

out = 'Team members:'

vm_rsp.add_team_members(team)

team.participants.each do |participant|

out = out + " (" + participant.fullname + ") "

end

expect(vm_rsp.display_team_members).to eq out

end

end

This code tests that when VMQuestionResponse is initialized with a team the team members can be displayed

context 'when given a list of valid questions' do

let(:qs) { qs = Array.new(1) { question2 } }

it 'can calculate the max score for the questionnaire' do

vm_rsp.add_questions qs

expect(vm_rsp.max_score).to eq 5

expect(vm_rsp.list_of_rows.size).to eq 1

expect(vm_rsp.max_score_for_questionnaire()).to eq qs.size * rq.max_question_score

end

end

This code tests VMQuestionResponse knows the max score for the questionnaire.

it 'has the round value of the given questionnaire' do

expect(vm_rsp.round).to eq 1

end

This code checks that VMQuestionResponse knows the value of @round for the given questionnaire.

context 'is initialized with an AuthorFeedbackQuestionnaire' do

[mock setup omitted for brevity]

it 'adds reviews' do

# review = double('review1')

# review.stub(:map_id => 1, :response_id => 1)

# allow(review).to receive_messages(:map_id => 1)

# ppnt0 = double('ppnt0')

# allow(ppnt0).to receive_messages(:feedback => [review])

# ppnt1 = double('ppnt1')

# allow(ppnt1).to receive_messages(:fullname => 'Python')

# mapping = double

# allow(mapping).to receive_messages(:first => mapping, :reviewer_id => 2)

# allow(FeedbackResponseMap).to receive_messages(:where => mapping)

# allow(Participant).to receive_messages(:find => ppnt1)

# vm_rsp.add_questions qs

# vm_rsp.add_reviews(ppnt0, '', false)

# expect(vm_rsp.list_of_reviews.size).to eq 1

# expect(vm_rsp.list_of_reviewers.size).to eq 1

# expect(vm_rsp.list_of_reviews).to eq [ppnt1]

end

it 'adds answers' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

end

it 'gets the number of comments greater than 10 words' do

allow(FeedbackResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

allow(Answer).to receive_messages(:where => [ans])

allow(TagPromptDeployment).to receive_messages(:where => [tag_dep])

allow(Question).to receive_messages(:find => question2)

allow(TagPrompt).to receive_messages(:find => true)

allow(VmTagPromptAnswer).to receive_messages(:new => '')

allow(VmQuestionResponseScoreCell).to receive_messages(:new => '')

row = double('row')

allow(row).to receive_messages(:countofcomments => 7, :question_id => 2,

:question_max_score => 5, :score_row => [3])

allow(VmQuestionResponseRow).to receive_messages(:new => row)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_rows.size).to eq 1

vm_rsp.get_number_of_comments_greater_than_10_words

expect(vm_rsp.list_of_rows[0].countofcomments).to eq 7

end

end

The above tests cover the scenario in which VMQuestionResponse is initialized with @questionnaire_type = "AuthorFeedbackQuestionnaire". We check that VMQuestionResponse can add revews, add answers, and retrieve the number of comments greater than 10 words in length. Here the test for add_reviews is commented out because it is still being developed.

context 'is initialized with an TeammateReviewQuestionnaire' do

let(:tmrq) { create(:questionnaire, name: "TeammateReviewQuestionnaire",

type: 'TeammateReviewQuestionnaire') }

let(:vm_rsp) { VmQuestionResponse.new( tmrq, assignment, 1 ) }

let(:question2) { create(:question, questionnaire: tmrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

it 'adds reviews' do

allow(TeammateReviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "TeammateReviewQuestionnaire".

context 'is initialized with an MetareviewQuestionnaire' do

let(:mrq) { create(:questionnaire, name: "MetareviewQuestionnaire", type: 'MetareviewQuestionnaire') }

let(:question2) { create(:question, questionnaire: mrq, weight: 2, id: 2, type: 'good') }

let(:qs) { qs = Array.new(1) { question2 } }

let(:vm_rsp) { VmQuestionResponse.new( mrq, assignment, 1 ) }

it 'adds reviews' do

allow(MetareviewResponseMap).to receive_messages(:where => mapping)

allow(Participant).to receive_messages(:find => ppnt1)

vm_rsp.add_questions qs

vm_rsp.add_reviews(ppnt0, '', false)

expect(vm_rsp.list_of_reviews.size).to eq 1

expect(vm_rsp.list_of_reviewers.size).to eq 1

expect(vm_rsp.list_of_reviews).to eq [review]

end

end

This code checks that we can add reviews when VMQuestionResponse is initialized with @questionnaire_type = "MetaReviewQuestionnaire".

== Results ==

We have now attained 91% coverage.

== Links/Resources ==

[https://github.com/mfleader42/expertiza/blob/master/spec/models/vm_question_response_spec.rb spec/models/vm_question_response_spec.rb]

E1849 vm question response spec

2018-11-02T18:25:07Z

Mfleader: VM Question Response Tests in RSpec

VM Question Response Tests in RSpec