Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-05-02T04:46:41Z

Sbose2:

This page provides information about the documentation of E2241: Heatgrid fixes and improvements as part of CSC/ECE 517 Spring 2022 Final project.
__TOC__

<h2> Team </h2>
<h3> Mentor </h3>
*Nicholas Himes (nnhimes)
<h3> Team Members (PinkPatterns) </h3>
* Eshwar Chandra Vidhyasagar Thedla (ethedla)
* Gokul Krishna Koganti (gkogant)
* Jyothi Sumer Goud Maduru (jmaduru)
* Suneha Bose (sbose2)

<h2> Heat Grid </h2>

Heat Grid refers to a part of view in Expertiza that shows review scores of all the reviews done for a particular assignment. It shows scores given for each rubric by peer reviewers. This is used by instructors to assign scores to individual assignments and by students to view review scores of their assignment. Our project scope involves dealing with fixing issues related to the heat grid and any subsequent bugs that might arrive.

<h2> Issues identified </h2>
<h3> Issue #2019: Restrict teammates from reviewing their own work</h3>
<p> There are some instances where a student was shown as reviewing his/her team even though the "Allow Self Review" checkbox was not checked by the instructor. This situation should not arise for practical purposes. Test cases must be extensively added so that we can be notified if the bug occurs again. </p>

[[File:Screen Shot 2022-04-06 at 10.37.56 PM.png|center|450px]]

<h3> Issue #1869: Deal with the metrics of the heat grid</h3>
<p> <b>metric-1</b> column name in the heat grid follows bad naming convention. It doesn't explain what the column refers to. This must be changed to make the column name more apt.</p>
<p> As of now, the heat grid uses only one metric (metric-1). We must facilitate the system for addition of new metrics. Instructors should be able to toggle between various metrics as per their preferences. This can be done by the use of a drop down menu.</p>

[[File:Screen Shot 2022-04-06 at 10.34.47 PM.png|center|550px]]

<h2> Design Principle </h2>
<p>
For Issue #1869 we plan to use the Factory Design Pattern since we are dealing with the creation of multiple kinds of metrics. As part of our implementation, we plan on using a metric interface, which can be implemented by different concrete metric classes. A factory class acts as a middleman between the implementations and the main class that instantiates the objects. Based on the instructor's selection, the main class requests the metric object from the factory class, rather than dealing with the creation logic on its own. This pattern, therefore, enforces encapsulation and results in the low coupling, the principle which is our primary target for this project scope.
</p>
<p>
The previous implementation has dealt with issue #1869. But the drawback with the implementation is that it renders a code that is highly coupled. Whenever a new metric is added two files (assignments/edit/_general.html.erb and grades/view_team.html.erb) are to be changed, resulting in high coupling. As a consequence, tests pertaining to the highly coupled codes require new tests as a new metric is added. This is undesirable. So, the principle of low coupling is the main focus of our implementation. This principle will enable a common set of tests that would be valid for any number of metrics that will potentially be added in the future.
</p>
<h2> Files to be targeted </h2>

<h3>Issue #2019</h3>
<p> Test file for adding test cases to implement self-reviews checks </p>
* spec/controllers/grades_controller_spec.rb

<h3>Issue #1869</h3>
<p>For Heat grid view</p>
* app/views/grades/_view_heatgrid.html.erb
* app/views/grades/view_team.html.erb
* app/helpers/grades_helper.rb
* app/controllers/grades_controller.rb
* app/models/vm_question_response.rb
* app/models/vm_question_row.rb
* assets/view_team_in_grades.js
<p>For Assignment view</p>
* app/views/assignment/edit/_general.html.erb
* app/controllers/assignments_controller.rb

<h2> Implementation of Issue 1869</h2>

<h3> Previous team’s implementation </h3>

<p> The previous team has dealt with the issue by changing “metric-1” to “verbose comment count”, which is relevant to what metric-1 refers to. For the latter half of the issue, they have provided a metric dropdown for the instructor to select while creating the assignment. This consequently requires only one metric to be displayed on the heat grid for which they’ve given a toggle option to show and hide the metric.
</p>

<h4> Changes reflected in the UI </h4>

<ul>
<li> <b> metric-1 </b> changed to verbose comment count </li>
[[File:Heatgrid-metric.png|600px]]

<li> Metric dropdown provided while creating an assignment </li>
[[File:Assignment General page.png|600px]]

</ul>

<h4> Issue with previous team's implementation </h4>

<p> The critical problem with their changes was, when in future a new metric is added, it forces a change in two view files: one time in assignments/edit/_general.html.erb and two times in grades/view_team.html.erb. Requiring these changes in view files that have little relevance to the heat grid is essentially causing high coupling. </p>

<h3> Current implementation </h3>

<h4> Issue Goal </h4>
<p> Our mentor has required us to display metrics in the heat grid with a toggle option for the user to select only the required metrics according to their preferences. This should be done keeping in mind low coupling as the primary design goal. These changes should be accompanied by minor changes such as adding comments and changing the name of “metric-1” to a self-indicative name. </p>

<h4> Implementation details </h4>
<p>
In the original beta implementation, whenever the relevant view file is loaded, it is calling the method "populate_view_model" present in the "grades_controller.rb" file. This method, is explicitly calling another model method to calculate metric. Whenever a new metric is added, we will have to make a call to that metric in the populate view model. This is not ideal as each new metric added is introducing a new line of code in the controller body. It is also not possible to determine the metrics present dynamically. To deal with this problem, we introduced a new parent method "calculate_metrics" in model file "vm_question_response.rb". This method is responsible for calling other individual methods that calculate metrics. The call to this method is replacing the explicit calls to metric calculation in the controller. This essentially is breaking the dependency between new metric introduction and the controller. Now, whenever a new metric is added, there is no need to introduce any code changes in the controller, instead we just have to change the code in relevant model file.
</p>
<p>
[[File:Heatgrid-2022-10.png|600px]] <br/>
</p>
<p>
[[File:Heatgrid-2022-11.png|600px]] <br/>
</p>
<p>
[[File:Heatgrid-2022-13.png|600px]] <br/>
</p>

<p>A new hashmap is introduced to store the values of the metrics in the form of key value pairs. Instead of explicitly calling metrics by name in the view file, this hashmap is used to iterate over the metrics and displayed</p>

<p>
[[File:Heatgrid-2022-20.png|600px]] <br/>
</p>
<p>
[[File:Heatgrid-2022-21.png|600px]] <br/>
</p>
<p>
[[File:Heatgrid-2022-22.png|600px]] <br/>
</p>

Toggle feature is implemented in "view_team_in_grades.js" file. When the checkbox is clicked, function in javascript file is called and appropriate elements are hidden.

<p>
[[File:Heatgrid-2022-23.png|600px]] <br/>
</p>

<h4> Adding a new metric in future </h4>

<p> To introduce new metric, a new method should be added in "vm_question_response.rb" file. This newly added method should be called from "calculate_metrics" method </p>

<p>
[[File:Heatgrid-2022-30.png|600px]] <br/>
</p>

<p>
[[File:Heatgrid-2022-31.png|600px]] <br/>
</p>

<h4>Changes reflected in the UI</h4>

<p>
[[File:Heatgrid-2022-40.png|600px]] <br/>
</p>
<p>
[[File:Heatgrid-2022-41.png|600px]] <br/>
</p>
<p>
[[File:Heatgrid-2022-43.png|600px]] <br/>
</p>

<h4> Manual Testing </h4>

<pre>
Scenario: Visibility of all the unchecked metric checkboxes in View Scores view
Given user has logged in
When user visits View Scores page
Then all the unchecked metric checkboxes are present above the heat grid
</pre>

<pre>
Scenario: Default invisibility of metric columns in View Scores view
Given user has logged in
When user visits View Scores page
Then metric columns are not visible in the heat grid
</pre>

<pre>
Scenario: Checking a metric checkbox displays the corresponding metric column
Given user has logged in
When user visits View Scores page and
When user clicks on unchecked comments#10 metric
Then column with column name " comments#10" gets displayed with corresponding values
</pre>

<pre>
Scenario: Unchecking a metric checkbox hides the corresponding metric column
Given user has logged in
When user visits View Scores page and
When user clicks on checked comments#10 metric
Then column with column name " comments#10" and corresponding values get hidden
</pre>

<h4> Unit Testing </h4>
<p>As our project does not deal with actually adding new metrics, but just facilitating a low-coupling addition of new metrics, we need not add any unit test cases for metric implementations. There is only one metric in the system as of now for which test cases are already written.</p>

<h2>Implementation of Issue 2019</h2>
<p> This issue encompasses many problems such as review reports not displaying correctly and a user being able to review his/her work. Each problem has been dealt with individually. Main problems identified as part of this issue and relevant observations and corrections are jotted down in this section. </p>

<h3> Problem 1 : A user being able to review his/her own work.</h3>

<h4> Problem comment </h4>
<p> On Madeup Problem 3, assignment 1055, there are several anomalies in the review report. User 9277 reviewed Team_2323 and gave this comment: "This question seems a little suspicious. It is nearly identical to Question 4a on page 327 in the 2016 edition book. The only thing change was variable name A to B and value 2 to 3." However, according to the View Submissions page, User 9277 is the only member of Team_2323. </p>

<h4> Issue Reproduction and Observations </h4>
<p> We tried reproducing the issue as specified in the issue comment, but we could not find Madeup Problem 3, assignment 1055. So, we have created two assignments with different parameters to check if the instructor is able to assign a reviewer his/her own work. </p>

<p> We have created an assignment "Noself review" with allow self review option unchecked. Then, from the instructor page, we have created a team with student13 and student 14 as teammates. Then we logged into student14 account and submitted a hyperlink for that assignment. After that, from the instructor page we clicked on the assign review button and tried assigning student13 as the reviewer for that work and then tried the same with student14. In both the cases, the assignment failed by rendering a flash error message, "You cannot assign this student to review his/her own artifact." </p>
<ul>
<li> Unchecked allow self-review option in "Noself review" assignment </li>
[[File:self-review-option-unchecked.png|600px]]<br/>

<li> Participants page containing add reviewer button </li>
[[File:Duo-team-submission.png|600px]]<br/>

<li> Adding student13 as reviewer for his/her own work </li>
[[File:Self-assign-review.png|600px]]<br/>

<li> Flash error message displayed</li>
[[File:self-review-unchecked.png|600px]]<br/>
</ul>
<p> We followed the same process for "self_review assignment", which gave student an option to self review his/her own work immediately after submitting their work. However, when the instructor tried assigning the user with his/her own work, same flash error message was displayed, not allowing the user to review their work.</p>

<li> Checked allow self-review option in "self_review assignment" </li>
[[File:Self-review-checked.png|600px]]<br/>

<li> Participants page of self review assignment</li>
[[File:Participants_page_for_self-review_assignment.png|600px]]<br/>

<li> Assigning student13 as reviewer for own work</li>
[[File:Student-13-self-review.png|600px]]<br/>

<li> Display of error message after assigning own artifact</li>
[[File: Error-message-checked.png|600px]]<br/>

<h4> Test case added</h4>
<p> Previously implemented test cases of review_map controller have covered most of the tests pertaining to a user being assigned review work for his own artifact. These test cases primarily focused on the add_reviewer function of the review_mapping controller. However a test case checking for the display of flash error message on trying to assign reviewer to his/her own work was not covered, which we have added in the respective spec file. </p>

<pre>
Scenario: Display of flash error message when instructor tries student their own artifact for reviewing
Given instructor has logged in
When the instructor visits the assignment page and
When the instructor clicks on assign reviewer for an assignment and
when the instructor tries to assign the owner of the artifact as the reviewer
Then a flash error message is displayed saying "You cannot assign this student to review his/her own artifact."
</pre>

<pre>
context 'when instructor tries to assign a student their own artifact for reviewing' do
it 'flashes an error message' do
allow(TeamsUser).to receive(:exists?).with(team_id: '1', user_id: 1).and_return(true)
post :add_reviewer, @params
expect(flash[:error]).to eq('You cannot assign this student to review his/her own artifact.')
expect(response).to redirect_to '/review_mapping/list_mappings?id=1'
end
end
</pre>

<h3> Problem 2 : Review comments from the first round not being displayed</h3>

<h4> Problem comment </h4>
<p> The Round 1 review (and the Round 1 heat grid) are missing when the instructor (instructor6) goes to Assign Grade for Student 9277. The Round 1 review should be in the first heat grid on the Assign Grades page. </p>

<h4> Issue Reproduction and Observations </h4>
<p> For this problem, we have tried the similar thing as the first problem. We have observed that if the instructor checks the option "review rubric varies by round" when the instructor creates an assignment, reviews from all the rounds are displayed in the heat grid. When the instructor unchecks that option, only the most recent review set is being displayed. As this is dependent on the user preference, we identified this not to be a problem. </p>

<ul>
<li> Review rubric varies by round option, which is unchecked by default </li>
[[File: Unchecked-rubric-varies.jpeg|600px]]<br/>

<li> Display of only the reviews of latest round when "Review rubric varies by round" is unchecked</li>
[[File:Latest_review_on_uncheck.jpeg|600px]]<br/>

<li> Display of reviews of all the rounds when "Review rubric varies by round" is checked</li>
[[File:All-round-display.jpeg|600px]]<br/>

</ul>

<h2> Important Links </h2>
* [https://youtu.be/K8rCxSZZOho/ Demo Video]
* [https://github.com/EshwarCVS/expertiza/ GitHub repository link]
* [https://docs.google.com/document/d/1H0BjzMBz5it7Wckhegq4LXhMi8RVctTwVzP2x9gnFCo/edit#heading=h.tqdrrd12xs4x/ Project Description Document]
* [https://github.com/expertiza/expertiza/issues/1869/ GitHub Issue #1869]
* [https://github.com/expertiza/expertiza/issues/2019/ GitHub Issue #2019]

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-12T03:38:34Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-12T00:55:09Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-12T00:39:50Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-12T00:25:37Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-12T00:23:44Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-07T03:20:21Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-07T03:11:47Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-07T03:10:24Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-07T02:46:51Z

Sbose2:

This page provides information about the refactoring work done on the reputation web service controller as part of the OSS project.

__TOC__

<h2> Team </h2>
<h3> Mentor </h3>
*Nicholas Himes (nnhimes)
<h3> Team Members (PinkPatterns) </h3>
* Eshwar Chandra Vidhyasagar Thedla (ethedla)
* Gokul Krishna Koganti (gkogant)
* Jyothi Sumer Goud Maduru (jmaduru)
* Suneha Bose (sbose2)

<h2> Heat Grid </h2>

Heat Grid refers to a part of view in expertiza that shows review scores of all the reviews done for a particular assignment. It shows scores given for each rubric by peer reviewers. This is used by instructors to assign scores to individual assignments and by students to view review scores of their assignment. Our project scope involves dealing with fixing issues related to the heat grid and any subsequent bugs that might arrive.

<h2> Issues identified </h2>
<h3> Restrict teammates from reviewing their own work (Issue #2019)</h3>
<p> There are some instances where a student was shown as reviewing his/her team. This is impossible and is classified as a bug. This must be dealt with. Test cases must be extensively added so that we can be notified if the bug occurs again. </p>

[[File:Screen Shot 2022-04-06 at 10.37.56 PM.png|center|450px]]

<h3> Deal with the metrics of the heat grid (Issue #1869)</h3>
<p> <b>metric-1</b> column name in the heat grid follows bad naming convention. It doesn't explain what the column refers to. This must be changed to make the column name more apt.</p>
<p> As of now, the heat grid uses only one metric (metric-1). We must facilitate the system for addition of new metrics. Instructors should be able to toggle between various metrics as per their preferences. This can be done by the use of a drop down menu.</p>

[[File:Screen Shot 2022-04-06 at 10.34.47 PM.png|center|550px]]

<h2> Plan of work </h2>
<h3> Restrict teammates from reviewing their own work (Issue #2019)</h3>
<p>Relevant bug of this issue can’t be reproduced to deal with it. So comprehensive test cases must be written to be notified if the bug arises again. We are planning to add rspec unit tests covering the following cases:
</p>
<ul>
<li><b> If the instructor unchecks “ Allow self review” option</b></li>
<ol>
<li> Instructor should not be able to assign a student to review work that he/she has submitted. </li>
<li> Instructor should not be able to assign a student to review work that their teammate has submitted.</li>
<li> Students should not be able to review work he/she has submitted.</li>
<li> Students should not be able to review work a teammate has submitted.</li>
</ol>
<li><b> If the instructor checks “ Allow self review” option</b></li>
<ol>
<li> Instructor should be able to assign a student to review work that he/she has submitted.</li>
<li> Instructor should be able to assign a student to review work that their teammate has submitted.</li>
<li> Students should be able to review work he/she has submitted. </li>
<li> Students should be able to review work a teammate has submitted.</li>
</ol>
</ul>

<h3> Deal with the metrics of the heat grid (Issue #1869)</h3>
<p>The new metrics can be added to the Metrics table that we will create. While creating an assignment/ editing an assignment, the instructor can select a metric from the Metrics table which will be available as a dropdown menu. We will retrieve the metric selected for the assignment by the instructor and display it in the Heatgrid Map of reviews.</p>

<h4> Proposed Control Flow </h4>
[[File:Proposed_Control_Flow.drawio.png]]

<h2> Files to be targeted </h2>
<h3>Issue #1869</h3>
<p>For Heat grid</p>
* app/views/grades/_view_heatgrid.html.erb
* app/views/grades/view_team.html.erb
* app/helpers/grades_helper.rb
* app/controllers/grades_controller.rb
* app/models/vm_question_response.rb
* app/models/vm_question_row.rb
<p>For Assignment</p>
* app/views/assignment/edit/_general.html.erb
* app/controllers/assignments_controller.rb

<h2> Test Plan </h2>
* Capybara Test cases for testing the UI of heat grid view with the expected metric for the respective assignment and the UI of team view with relevant metric selected with all other metrics in the dropdown
* Spec test cases for testing the grades controller and assignment controller to check if they are returning the values as expected
* Unit test cases will be added to verify the logic behind the methods to calculate the values for their metrics

<h2> Important Links </h2>
* GitHub repository link: https://github.com/EshwarCVS/expertiza
* Project Description Document: https://docs.google.com/document/d/1H0BjzMBz5it7Wckhegq4LXhMi8RVctTwVzP2x9gnFCo/edit#heading=h.tqdrrd12xs4x
* GitHub Issue #1869: https://github.com/expertiza/expertiza/issues/1869
* GitHub Issue #2019: https://github.com/expertiza/expertiza/issues/2019

File:Screen Shot 2022-04-06 at 10.37.56 PM.png

2022-04-07T02:39:51Z

Sbose2: Self review screenshot

Self review screenshot

File:Screen Shot 2022-04-06 at 10.34.47 PM.png

2022-04-07T02:38:46Z

Sbose2: Heatgrid Screenshot

Heatgrid Screenshot

CSC/ECE 517 Spring 2022 - E2241: Heatgrid fixes and improvements

2022-04-07T02:34:15Z

Sbose2:

This page provides information about the refactoring work done on the reputation web service controller as part of the OSS project.

__TOC__

<h2> Team </h2>
<h3> Mentor </h3>
*Nicholas Himes (nnhimes)
<h3> Team Members (PinkPatterns) </h3>
* Eshwar Chandra Vidhyasagar Thedla (ethedla)
* Gokul Krishna Koganti (gkogant)
* Jyothi Sumer Goud Maduru (jmaduru)
* Suneha Bose (sbose2)

<h2> Heat Grid </h2>

Heat Grid refers to a part of view in expertiza that shows review scores of all the reviews done for a particular assignment. It shows scores given for each rubric by peer reviewers. This is used by instructors to assign scores to individual assignments and by students to view review scores of their assignment. Our project scope involves dealing with fixing issues related to the heat grid and any subsequent bugs that might arrive.

<h2> Issues identified </h2>
<h3> Restrict teammates from reviewing their own work (Issue #2019)</h3>
<p> There are some instances where a student was shown as reviewing his/her team. This is impossible and is classified as a bug. This must be dealt with. Test cases must be extensively added so that we can be notified if the bug occurs again. </p>
<h3> Deal with the metrics of the heat grid (Issue #1869)</h3>
<p> <b>metric-1</b> column name in the heat grid follows bad naming convention. It doesn't explain what the column refers to. This must be changed to make the column name more apt.</p>
<p> As of now, the heat grid uses only one metric (metric-1). We must facilitate the system for addition of new metrics. Instructors should be able to toggle between various metrics as per their preferences. This can be done by the use of a drop down menu.</p>

<h2> Plan of work </h2>
<h3> Restrict teammates from reviewing their own work (Issue #2019)</h3>
<p>Relevant bug of this issue can’t be reproduced to deal with it. So comprehensive test cases must be written to be notified if the bug arises again. We are planning to add rspec unit tests covering the following cases:
</p>
<ul>
<li><b> If the instructor unchecks “ Allow self review” option</b></li>
<ol>
<li> Instructor should not be able to assign a student to review work that he/she has submitted. </li>
<li> Instructor should not be able to assign a student to review work that their teammate has submitted.</li>
<li> Students should not be able to review work he/she has submitted.</li>
<li> Students should not be able to review work a teammate has submitted.</li>
</ol>
<li><b> If the instructor checks “ Allow self review” option</b></li>
<ol>
<li> Instructor should be able to assign a student to review work that he/she has submitted.</li>
<li> Instructor should be able to assign a student to review work that their teammate has submitted.</li>
<li> Students should be able to review work he/she has submitted. </li>
<li> Students should be able to review work a teammate has submitted.</li>
</ol>
</ul>

<h3> Deal with the metrics of the heat grid (Issue #1869)</h3>
<p>The new metrics can be added to the Metrics table that we will create. While creating an assignment/ editing an assignment, the instructor can select a metric from the Metrics table which will be available as a dropdown menu. We will retrieve the metric selected for the assignment by the instructor and display it in the Heatgrid Map of reviews.</p>

<h4> Proposed Control Flow </h4>
[[File:Proposed_Control_Flow.drawio.png]]

<h2> Files to be targeted </h2>
<h3>Issue #1869</h3>
<p>For Heat grid</p>
* app/views/grades/_view_heatgrid.html.erb
* app/views/grades/view_team.html.erb
* app/helpers/grades_helper.rb
* app/controllers/grades_controller.rb
* app/models/vm_question_response.rb
* app/models/vm_question_row.rb
<p>For Assignment</p>
* app/views/assignment/edit/_general.html.erb
* app/controllers/assignments_controller.rb

<h2> Test Plan </h2>
* Capybara Test cases for testing the UI of heat grid view with the expected metric for the respective assignment and the UI of team view with relevant metric selected with all other metrics in the dropdown
* Spec test cases for testing the grades controller and assignment controller to check if they are returning the values as expected
* Unit test cases will be added to verify the logic behind the methods to calculate the values for their metrics

<h2> Important Links </h2>
* GitHub repository link: https://github.com/EshwarCVS/expertiza
* Project Description Document: https://docs.google.com/document/d/1H0BjzMBz5it7Wckhegq4LXhMi8RVctTwVzP2x9gnFCo/edit#heading=h.tqdrrd12xs4x
* GitHub Issue #1869: https://github.com/expertiza/expertiza/issues/1869
* GitHub Issue #2019: https://github.com/expertiza/expertiza/issues/2019

File:Proposed Control Flow.drawio.png

2022-04-07T02:29:06Z

Sbose2:

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-27T21:20:11Z

Sbose2: /* Running Tests */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is the software benefits for both instructors and students by supporting various types of submissions and providing reusable objects for peer review. It is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. It allows the instructors not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams to work on various projects and assignments. Expertiza also lets students peer-review other students' submissions, enabling them to work together to improve others' learning experiences.

== Description about project ==
This page is a description of Expertiza OSS project E2202 which is adding test cases for badges_controller.rb and publishing_controller.rb. The badges controller allows users to create badges by entering the badge name, description and an image that serves as the badge icon. The publishing controller enables the students to grant/revoke publishing rights to past assignments. It does this by either allowing the students to grant and deny rights individually or all of them together. It makes use of the private key to verify the digital signature of the user granting the rights.

=== Files Involved ===

badges_controller.rb

badges_controller_spec.rb

publishing_controller.rb

publishing_controller_spec.rb

=== Running Tests ===

<pre>

rspec spec/controllers/publishing_controller_spec.rb spec/controllers/badges_controller_spec.rb

</pre>

* If you're having any difficulty in running the tests, please drop an email to sbose2@ncsu.edu, apatil25@ncsu.edu or kkhulla@ncsu.edu.

== Test Plan ==
After setting up the development environment, we ran the original test cases for the badges_controller. However the test cases were very limited and only partially covered one of the methods. We wrote additional test cases to cover all the 5 methods badges controller and expanded the existing test case.
For the publishing_controller no tests were available so we had to write every test from scratch. We have written tests to cover all the 6 methods in the publishing_controller. In total we wrote 27 test cases for both the controllers. We used object mocking for creating the unit test cases.

====Badges Controller Methods====
The methods in the controller are:

*action_allowed?
*new
*redirect_to_assignment
*create
*badge_params

====Publishing Controller Methods====
The methods in the controller are:

*action_allowed?
*view
*set_publish_permission
*update_publish_permissions
*grant
*grant_with_private_key

====Test Frame for Badges Controller====

1. action_allowed? - When user tries to access the badges this method is called to check if the current user is authorized to view this page. All the users except the user with student privileges has access to perform actions in badges.

Code snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'refuses student from performing certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_falsey
end

it 'allows teaching assisstant to perform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. New - When user tries to create a new badge it redirects to the new create badge page and allow the user to enter details for the badge creation.

Code snippet:
<pre>
describe '#new' do
context 'when user wants to create a new badge' do
it 'should call the new#badge page url' do
get :new
expect(get: 'badges/new').to route_to('badges#new')
end

it 'should render the create new form and allow the user to enter details' do
allow(Badge).to receive(:new).and_return(badge)
params = {}
session = { user: instructor1 }
get :new, params, session
expect(response).to render_template('new')
end
end
end
</pre>

3. redirect_to_assignment - When the user has successfully created a badge it redirects to the assignment page.

Code Snippet:
<pre>
describe 'redirect_to_assignment' do
context 'after user successfully creates a badge' do
it 'calls the redirect_to_assignment url' do
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
expect(get: 'badges/redirect_to_assignment').to route_to('badges#redirect_to_assignment')
end

it 'redirects to the assignment page' do
stub_current_user(ta, ta.role.name, ta.role)
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
response.should redirect_to("http://test.host/assignments/844/edit")
end
end
end
</pre>

4. create - When the user tries to create a badge by entering all the required details, it saves the badge. If there are any missing required details for badge creation it throws an error for missing fields.

Code Snippet:
<pre>
describe '#create' do
context 'when user enters all the required badge details correctly' do
it 'should save the badge successfully' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to redirect_to 'http://test.host/assignments/844/edit'
end
end

context 'when user forgets to enter few of the required badge details' do
it 'should throw an error for missing image file' do
@file = nil
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge name' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: '',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge description' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: '',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end
end
end
</pre>

====Test Frame for Publishing Controller====

1. action_allowed? - When user tries to grant or view publishing rights this method is called to check if the current user is authorized to perform the action. All users with student privileges have access to perform actions for publishing.

Code Snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows student to perform certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows teaching assisstant to peform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. view - When user visits the publishing rights page, it displays all past assignment participants.

Code Snippet:
<pre>
describe 'view' do
context 'user visits the publishing rights page' do
it 'displays all the assignment participants' do
stub_current_user(student1, student1.role.name, student1.role)
params = { id: 21 }
get :view, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

3. set_publish_permission - When the user matches with the participant and the user clicks on the grant button next to the assignment, it redirects to the grant page.
When the user matches with the participant and the assignment is already granted permission, it redirects to the view page.

Code Snippet:
<pre>
describe 'set_publish_permission' do
context 'user matches with participant and user clicks on the grant button next to the assignment' do
it 'redirects to the grant page' do
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 1, allow: 1}
post :set_publish_permission, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user matches with participant and the assignment is already granted permission' do
it 'redirects to the view page' do
stub_current_user(student1, student1.role.name, student1.role)
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
allow(assignment_participant1).to receive(:update_attribute).and_return(true)
params ={id: 1, allow: '0'}
post :set_publish_permission, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

4. update_publish_permissions - When a user clicks on the grant publishing rights to all past assignments button it redirects to the grant page.
When a user clicks on the deny publishing rights to all past assignments button it redirects to the view page.

Code Snippet:
<pre>
describe 'update_publish_permissions' do
context 'user clicks on the grant publishing rights to all past assignments button' do
it 'redirects to grant page' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 1}
post :update_publish_permissions, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user clicks on the deny publishing rights to all past assignments button' do
it 'redirects to view page' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 0}
[assignment_participant1].each do |participant|
allow(participant).to receive(:update_attribute).and_return(true)
allow(participant).to receive(:save).and_return(true)
end
post :update_publish_permissions, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

5. grant - When a user clicks on the grant publishing option, it displays the page where the user can supply their private key and grant publishing rights.

Code Snippet:
<pre>
describe 'grant' do
context 'user clicks on grant option' do
it 'displays the page where the user can supply their private key and grant publishing rights' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3}
get :grant, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

6. grant_with_private_key - When a user visits the grant page without id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant page.
When a user visits the grant page with id and enters correct RSA private key, it verifies key to be successful for all past assignments and redirects to view page.
When a user visits the grant page with id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant.

Code Snippet:
<pre>
describe 'grant_with_private_key' do

context 'user visits the grant page without id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params = {}
private_key = double(:private_key)
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(private_key).and_return(true)
allow(participant).to receive(:assign_copyright).with(private_key).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant)
end
end

context 'user visits the grant page with id and enters correct RSA private key' do
it 'verifies to be successful for all past assignments and redirect to view' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_return(true)
end
post :grant_with_private_key, params
expect(response).to redirect_to(action: :view)
end
end

context 'user visits the grant page with id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant,params:{id:2})
end
end
end
</pre>

==Results==

The total coverage of the tests is 100%. We covered all the edges cases to ensure maximum coverage.

The screenshot for test coverage can be found [https://drive.google.com/file/d/1sYOvWfxMEUI3i81ir7Yaw49ilEFvryfg/view?usp=sharing here]

==Related Links==

A video of all the tests running can be found [https://drive.google.com/file/d/1yKN_zzzkNGzkVpwnLCh_WPBknZKfOr2t/view?usp=sharing here]

The pull request can be accessed [https://github.com/expertiza/expertiza/pull/2321 here]

The forked git repository for this project can be found [https://github.com/atharva1996/expertiza here]

==Conclusion==
We followed a behavior-driven approach to write unit tests for badges_controller and publishing_controller. We considered all edge cases to achieve 100% coverage of both the controllers.

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-27T20:58:34Z

Sbose2: /* Running Tests */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is the software benefits for both instructors and students by supporting various types of submissions and providing reusable objects for peer review. It is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. It allows the instructors not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams to work on various projects and assignments. Expertiza also lets students peer-review other students' submissions, enabling them to work together to improve others' learning experiences.

== Description about project ==
This page is a description of Expertiza OSS project E2202 which is adding test cases for badges_controller.rb and publishing_controller.rb. The badges controller allows users to create badges by entering the badge name, description and an image that serves as the badge icon. The publishing controller enables the students to grant/revoke publishing rights to past assignments. It does this by either allowing the students to grant and deny rights individually or all of them together. It makes use of the private key to verify the digital signature of the user granting the rights.

=== Files Involved ===

badges_controller.rb

badges_controller_spec.rb

publishing_controller.rb

publishing_controller_spec.rb

=== Running Tests ===

<pre>

rspec spec/controllers/publishing_controller_spec.rb spec/controllers/badges_controller_spec.rb

</pre>

* If you're having any difficulty in running the tests, please drop an email at sbose2@ncsu.edu, apatil25@ncsu.edu or kkhulla@ncsu.edu.

== Test Plan ==
After setting up the development environment, we ran the original test cases for the badges_controller. However the test cases were very limited and only partially covered one of the methods. We wrote additional test cases to cover all the 5 methods badges controller and expanded the existing test case.
For the publishing_controller no tests were available so we had to write every test from scratch. We have written tests to cover all the 6 methods in the publishing_controller. In total we wrote 27 test cases for both the controllers. We used object mocking for creating the unit test cases.

====Badges Controller Methods====
The methods in the controller are:

*action_allowed?
*new
*redirect_to_assignment
*create
*badge_params

====Publishing Controller Methods====
The methods in the controller are:

*action_allowed?
*view
*set_publish_permission
*update_publish_permissions
*grant
*grant_with_private_key

====Test Frame for Badges Controller====

1. action_allowed? - When user tries to access the badges this method is called to check if the current user is authorized to view this page. All the users except the user with student privileges has access to perform actions in badges.

Code snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'refuses student from performing certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_falsey
end

it 'allows teaching assisstant to perform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. New - When user tries to create a new badge it redirects to the new create badge page and allow the user to enter details for the badge creation.

Code snippet:
<pre>
describe '#new' do
context 'when user wants to create a new badge' do
it 'should call the new#badge page url' do
get :new
expect(get: 'badges/new').to route_to('badges#new')
end

it 'should render the create new form and allow the user to enter details' do
allow(Badge).to receive(:new).and_return(badge)
params = {}
session = { user: instructor1 }
get :new, params, session
expect(response).to render_template('new')
end
end
end
</pre>

3. redirect_to_assignment - When the user has successfully created a badge it redirects to the assignment page.

Code Snippet:
<pre>
describe 'redirect_to_assignment' do
context 'after user successfully creates a badge' do
it 'calls the redirect_to_assignment url' do
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
expect(get: 'badges/redirect_to_assignment').to route_to('badges#redirect_to_assignment')
end

it 'redirects to the assignment page' do
stub_current_user(ta, ta.role.name, ta.role)
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
response.should redirect_to("http://test.host/assignments/844/edit")
end
end
end
</pre>

4. create - When the user tries to create a badge by entering all the required details, it saves the badge. If there are any missing required details for badge creation it throws an error for missing fields.

Code Snippet:
<pre>
describe '#create' do
context 'when user enters all the required badge details correctly' do
it 'should save the badge successfully' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to redirect_to 'http://test.host/assignments/844/edit'
end
end

context 'when user forgets to enter few of the required badge details' do
it 'should throw an error for missing image file' do
@file = nil
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge name' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: '',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge description' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: '',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end
end
end
</pre>

====Test Frame for Publishing Controller====

1. action_allowed? - When user tries to grant or view publishing rights this method is called to check if the current user is authorized to perform the action. All users with student privileges have access to perform actions for publishing.

Code Snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows student to perform certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows teaching assisstant to peform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. view - When user visits the publishing rights page, it displays all past assignment participants.

Code Snippet:
<pre>
describe 'view' do
context 'user visits the publishing rights page' do
it 'displays all the assignment participants' do
stub_current_user(student1, student1.role.name, student1.role)
params = { id: 21 }
get :view, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

3. set_publish_permission - When the user matches with the participant and the user clicks on the grant button next to the assignment, it redirects to the grant page.
When the user matches with the participant and the assignment is already granted permission, it redirects to the view page.

Code Snippet:
<pre>
describe 'set_publish_permission' do
context 'user matches with participant and user clicks on the grant button next to the assignment' do
it 'redirects to the grant page' do
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 1, allow: 1}
post :set_publish_permission, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user matches with participant and the assignment is already granted permission' do
it 'redirects to the view page' do
stub_current_user(student1, student1.role.name, student1.role)
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
allow(assignment_participant1).to receive(:update_attribute).and_return(true)
params ={id: 1, allow: '0'}
post :set_publish_permission, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

4. update_publish_permissions - When a user clicks on the grant publishing rights to all past assignments button it redirects to the grant page.
When a user clicks on the deny publishing rights to all past assignments button it redirects to the view page.

Code Snippet:
<pre>
describe 'update_publish_permissions' do
context 'user clicks on the grant publishing rights to all past assignments button' do
it 'redirects to grant page' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 1}
post :update_publish_permissions, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user clicks on the deny publishing rights to all past assignments button' do
it 'redirects to view page' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 0}
[assignment_participant1].each do |participant|
allow(participant).to receive(:update_attribute).and_return(true)
allow(participant).to receive(:save).and_return(true)
end
post :update_publish_permissions, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

5. grant - When a user clicks on the grant publishing option, it displays the page where the user can supply their private key and grant publishing rights.

Code Snippet:
<pre>
describe 'grant' do
context 'user clicks on grant option' do
it 'displays the page where the user can supply their private key and grant publishing rights' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3}
get :grant, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

6. grant_with_private_key - When a user visits the grant page without id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant page.
When a user visits the grant page with id and enters correct RSA private key, it verifies key to be successful for all past assignments and redirects to view page.
When a user visits the grant page with id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant.

Code Snippet:
<pre>
describe 'grant_with_private_key' do

context 'user visits the grant page without id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params = {}
private_key = double(:private_key)
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(private_key).and_return(true)
allow(participant).to receive(:assign_copyright).with(private_key).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant)
end
end

context 'user visits the grant page with id and enters correct RSA private key' do
it 'verifies to be successful for all past assignments and redirect to view' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_return(true)
end
post :grant_with_private_key, params
expect(response).to redirect_to(action: :view)
end
end

context 'user visits the grant page with id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant,params:{id:2})
end
end
end
</pre>

==Results==

The total coverage of the tests is 100%. We covered all the edges cases to ensure maximum coverage.

The screenshot for test coverage can be found [https://drive.google.com/file/d/1sYOvWfxMEUI3i81ir7Yaw49ilEFvryfg/view?usp=sharing here]

==Related Links==

A video of all the tests running can be found [https://drive.google.com/file/d/1yKN_zzzkNGzkVpwnLCh_WPBknZKfOr2t/view?usp=sharing here]

The pull request can be accessed [https://github.com/expertiza/expertiza/pull/2321 here]

The forked git repository for this project can be found [https://github.com/atharva1996/expertiza here]

==Conclusion==
We followed a behavior-driven approach to write unit tests for badges_controller and publishing_controller. We considered all edge cases to achieve 100% coverage of both the controllers.

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-21T22:05:42Z

Sbose2: /* Conclusion */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is the software benefits for both instructors and students by supporting various types of submissions and providing reusable objects for peer review. It is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. It allows the instructors not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams to work on various projects and assignments. Expertiza also lets students peer-review other students' submissions, enabling them to work together to improve others' learning experiences.

== Description about project ==
This page is a description of Expertiza OSS project E2202 which is adding test cases for badges_controller.rb and publishing_controller.rb. The badges controller allows users to create badges by entering the badge name, description and an image that serves as the badge icon. The publishing controller enables the students to grant/revoke publishing rights to past assignments. It does this by either allowing the students to grant and deny rights individually or all of them together. It makes use of the private key to verify the digital signature of the user granting the rights.

=== Files Involved ===

badges_controller.rb

badges_controller_spec.rb

publishing_controller.rb

publishing_controller_spec.rb

=== Running Tests ===

<pre>

rspec spec/controllers/publishing_controller_spec.rb spec/controllers/badges_controller_spec.rb

</pre>

== Test Plan ==
After setting up the development environment, we ran the original test cases for the badges_controller. However the test cases were very limited and only partially covered one of the methods. We wrote additional test cases to cover all the 5 methods badges controller and expanded the existing test case.
For the publishing_controller no tests were available so we had to write every test from scratch. We have written tests to cover all the 6 methods in the publishing_controller. In total we wrote 27 test cases for both the controllers. We used object mocking for creating the unit test cases.

====Badges Controller Methods====
The methods in the controller are:

*action_allowed?
*new
*redirect_to_assignment
*create
*badge_params

====Publishing Controller Methods====
The methods in the controller are:

*action_allowed?
*view
*set_publish_permission
*update_publish_permissions
*grant
*grant_with_private_key

====Test Frame for Badges Controller====

1. action_allowed? - When user tries to access the badges this method is called to check if the current user is authorized to view this page. All the users except the user with student privileges has access to perform actions in badges.

Code snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'refuses student from performing certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_falsey
end

it 'allows teaching assisstant to perform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. New - When user tries to create a new badge it redirects to the new create badge page and allow the user to enter details for the badge creation.

Code snippet:
<pre>
describe '#new' do
context 'when user wants to create a new badge' do
it 'should call the new#badge page url' do
get :new
expect(get: 'badges/new').to route_to('badges#new')
end

it 'should render the create new form and allow the user to enter details' do
allow(Badge).to receive(:new).and_return(badge)
params = {}
session = { user: instructor1 }
get :new, params, session
expect(response).to render_template('new')
end
end
end
</pre>

3. redirect_to_assignment - When the user has successfully created a badge it redirects to the assignment page.

Code Snippet:
<pre>
describe 'redirect_to_assignment' do
context 'after user successfully creates a badge' do
it 'calls the redirect_to_assignment url' do
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
expect(get: 'badges/redirect_to_assignment').to route_to('badges#redirect_to_assignment')
end

it 'redirects to the assignment page' do
stub_current_user(ta, ta.role.name, ta.role)
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
response.should redirect_to("http://test.host/assignments/844/edit")
end
end
end
</pre>

4. create - When the user tries to create a badge by entering all the required details, it saves the badge. If there are any missing required details for badge creation it throws an error for missing fields.

Code Snippet:
<pre>
describe '#create' do
context 'when user enters all the required badge details correctly' do
it 'should save the badge successfully' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to redirect_to 'http://test.host/assignments/844/edit'
end
end

context 'when user forgets to enter few of the required badge details' do
it 'should throw an error for missing image file' do
@file = nil
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge name' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: '',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge description' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: '',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end
end
end
</pre>

====Test Frame for Publishing Controller====

1. action_allowed? - When user tries to grant or view publishing rights this method is called to check if the current user is authorized to perform the action. All users with student privileges have access to perform actions for publishing.

Code Snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows student to perform certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows teaching assisstant to peform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. view - When user visits the publishing rights page, it displays all past assignment participants.

Code Snippet:
<pre>
describe 'view' do
context 'user visits the publishing rights page' do
it 'displays all the assignment participants' do
stub_current_user(student1, student1.role.name, student1.role)
params = { id: 21 }
get :view, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

3. set_publish_permission - When the user matches with the participant and the user clicks on the grant button next to the assignment, it redirects to the grant page.
When the user matches with the participant and the assignment is already granted permission, it redirects to the view page.

Code Snippet:
<pre>
describe 'set_publish_permission' do
context 'user matches with participant and user clicks on the grant button next to the assignment' do
it 'redirects to the grant page' do
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 1, allow: 1}
post :set_publish_permission, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user matches with participant and the assignment is already granted permission' do
it 'redirects to the view page' do
stub_current_user(student1, student1.role.name, student1.role)
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
allow(assignment_participant1).to receive(:update_attribute).and_return(true)
params ={id: 1, allow: '0'}
post :set_publish_permission, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

4. update_publish_permissions - When a user clicks on the grant publishing rights to all past assignments button it redirects to the grant page.
When a user clicks on the deny publishing rights to all past assignments button it redirects to the view page.

Code Snippet:
<pre>
describe 'update_publish_permissions' do
context 'user clicks on the grant publishing rights to all past assignments button' do
it 'redirects to grant page' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 1}
post :update_publish_permissions, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user clicks on the deny publishing rights to all past assignments button' do
it 'redirects to view page' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 0}
[assignment_participant1].each do |participant|
allow(participant).to receive(:update_attribute).and_return(true)
allow(participant).to receive(:save).and_return(true)
end
post :update_publish_permissions, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

5. grant - When a user clicks on the grant publishing option, it displays the page where the user can supply their private key and grant publishing rights.

Code Snippet:
<pre>
describe 'grant' do
context 'user clicks on grant option' do
it 'displays the page where the user can supply their private key and grant publishing rights' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3}
get :grant, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

6. grant_with_private_key - When a user visits the grant page without id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant page.
When a user visits the grant page with id and enters correct RSA private key, it verifies key to be successful for all past assignments and redirects to view page.
When a user visits the grant page with id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant.

Code Snippet:
<pre>
describe 'grant_with_private_key' do

context 'user visits the grant page without id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params = {}
private_key = double(:private_key)
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(private_key).and_return(true)
allow(participant).to receive(:assign_copyright).with(private_key).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant)
end
end

context 'user visits the grant page with id and enters correct RSA private key' do
it 'verifies to be successful for all past assignments and redirect to view' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_return(true)
end
post :grant_with_private_key, params
expect(response).to redirect_to(action: :view)
end
end

context 'user visits the grant page with id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant,params:{id:2})
end
end
end
</pre>

==Results==

The total coverage of the tests is 100%. We covered all the edges cases to ensure maximum coverage.

==Related Links==

A video of all the tests running can be found [https://drive.google.com/file/d/1yKN_zzzkNGzkVpwnLCh_WPBknZKfOr2t/view?usp=sharing here]

The pull request can be accessed [https://github.com/expertiza/expertiza/pull/2321 here]

The forked git repository for this project can be found [https://github.com/atharva1996/expertiza here]

==Conclusion==
We followed a behavior-driven approach to write unit tests for badges_controller and publishing_controller. We considered all edge cases to achieve 100% coverage of both the controllers.

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-21T22:03:30Z

Sbose2: /* Related Links */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is the software benefits for both instructors and students by supporting various types of submissions and providing reusable objects for peer review. It is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. It allows the instructors not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams to work on various projects and assignments. Expertiza also lets students peer-review other students' submissions, enabling them to work together to improve others' learning experiences.

== Description about project ==
This page is a description of Expertiza OSS project E2202 which is adding test cases for badges_controller.rb and publishing_controller.rb. The badges controller allows users to create badges by entering the badge name, description and an image that serves as the badge icon. The publishing controller enables the students to grant/revoke publishing rights to past assignments. It does this by either allowing the students to grant and deny rights individually or all of them together. It makes use of the private key to verify the digital signature of the user granting the rights.

=== Files Involved ===

badges_controller.rb

badges_controller_spec.rb

publishing_controller.rb

publishing_controller_spec.rb

=== Running Tests ===

<pre>

rspec spec/controllers/publishing_controller_spec.rb spec/controllers/badges_controller_spec.rb

</pre>

== Test Plan ==
After setting up the development environment, we ran the original test cases for the badges_controller. However the test cases were very limited and only partially covered one of the methods. We wrote additional test cases to cover all the 5 methods badges controller and expanded the existing test case.
For the publishing_controller no tests were available so we had to write every test from scratch. We have written tests to cover all the 6 methods in the publishing_controller. In total we wrote 27 test cases for both the controllers. We used object mocking for creating the unit test cases.

====Badges Controller Methods====
The methods in the controller are:

*action_allowed?
*new
*redirect_to_assignment
*create
*badge_params

====Publishing Controller Methods====
The methods in the controller are:

*action_allowed?
*view
*set_publish_permission
*update_publish_permissions
*grant
*grant_with_private_key

====Test Frame for Badges Controller====

1. action_allowed? - When user tries to access the badges this method is called to check if the current user is authorized to view this page. All the users except the user with student privileges has access to perform actions in badges.

Code snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'refuses student from performing certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_falsey
end

it 'allows teaching assisstant to perform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. New - When user tries to create a new badge it redirects to the new create badge page and allow the user to enter details for the badge creation.

Code snippet:
<pre>
describe '#new' do
context 'when user wants to create a new badge' do
it 'should call the new#badge page url' do
get :new
expect(get: 'badges/new').to route_to('badges#new')
end

it 'should render the create new form and allow the user to enter details' do
allow(Badge).to receive(:new).and_return(badge)
params = {}
session = { user: instructor1 }
get :new, params, session
expect(response).to render_template('new')
end
end
end
</pre>

3. redirect_to_assignment - When the user has successfully created a badge it redirects to the assignment page.

Code Snippet:
<pre>
describe 'redirect_to_assignment' do
context 'after user successfully creates a badge' do
it 'calls the redirect_to_assignment url' do
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
expect(get: 'badges/redirect_to_assignment').to route_to('badges#redirect_to_assignment')
end

it 'redirects to the assignment page' do
stub_current_user(ta, ta.role.name, ta.role)
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
response.should redirect_to("http://test.host/assignments/844/edit")
end
end
end
</pre>

4. create - When the user tries to create a badge by entering all the required details, it saves the badge. If there are any missing required details for badge creation it throws an error for missing fields.

Code Snippet:
<pre>
describe '#create' do
context 'when user enters all the required badge details correctly' do
it 'should save the badge successfully' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to redirect_to 'http://test.host/assignments/844/edit'
end
end

context 'when user forgets to enter few of the required badge details' do
it 'should throw an error for missing image file' do
@file = nil
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge name' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: '',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge description' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: '',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end
end
end
</pre>

====Test Frame for Publishing Controller====

1. action_allowed? - When user tries to grant or view publishing rights this method is called to check if the current user is authorized to perform the action. All users with student privileges have access to perform actions for publishing.

Code Snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows student to perform certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows teaching assisstant to peform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. view - When user visits the publishing rights page, it displays all past assignment participants.

Code Snippet:
<pre>
describe 'view' do
context 'user visits the publishing rights page' do
it 'displays all the assignment participants' do
stub_current_user(student1, student1.role.name, student1.role)
params = { id: 21 }
get :view, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

3. set_publish_permission - When the user matches with the participant and the user clicks on the grant button next to the assignment, it redirects to the grant page.
When the user matches with the participant and the assignment is already granted permission, it redirects to the view page.

Code Snippet:
<pre>
describe 'set_publish_permission' do
context 'user matches with participant and user clicks on the grant button next to the assignment' do
it 'redirects to the grant page' do
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 1, allow: 1}
post :set_publish_permission, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user matches with participant and the assignment is already granted permission' do
it 'redirects to the view page' do
stub_current_user(student1, student1.role.name, student1.role)
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
allow(assignment_participant1).to receive(:update_attribute).and_return(true)
params ={id: 1, allow: '0'}
post :set_publish_permission, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

4. update_publish_permissions - When a user clicks on the grant publishing rights to all past assignments button it redirects to the grant page.
When a user clicks on the deny publishing rights to all past assignments button it redirects to the view page.

Code Snippet:
<pre>
describe 'update_publish_permissions' do
context 'user clicks on the grant publishing rights to all past assignments button' do
it 'redirects to grant page' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 1}
post :update_publish_permissions, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user clicks on the deny publishing rights to all past assignments button' do
it 'redirects to view page' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 0}
[assignment_participant1].each do |participant|
allow(participant).to receive(:update_attribute).and_return(true)
allow(participant).to receive(:save).and_return(true)
end
post :update_publish_permissions, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

5. grant - When a user clicks on the grant publishing option, it displays the page where the user can supply their private key and grant publishing rights.

Code Snippet:
<pre>
describe 'grant' do
context 'user clicks on grant option' do
it 'displays the page where the user can supply their private key and grant publishing rights' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3}
get :grant, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

6. grant_with_private_key - When a user visits the grant page without id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant page.
When a user visits the grant page with id and enters correct RSA private key, it verifies key to be successful for all past assignments and redirects to view page.
When a user visits the grant page with id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant.

Code Snippet:
<pre>
describe 'grant_with_private_key' do

context 'user visits the grant page without id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params = {}
private_key = double(:private_key)
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(private_key).and_return(true)
allow(participant).to receive(:assign_copyright).with(private_key).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant)
end
end

context 'user visits the grant page with id and enters correct RSA private key' do
it 'verifies to be successful for all past assignments and redirect to view' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_return(true)
end
post :grant_with_private_key, params
expect(response).to redirect_to(action: :view)
end
end

context 'user visits the grant page with id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant,params:{id:2})
end
end
end
</pre>

==Results==

The total coverage of the tests is 100%. We covered all the edges cases to ensure maximum coverage.

==Related Links==

A video of all the tests running can be found [https://drive.google.com/file/d/1yKN_zzzkNGzkVpwnLCh_WPBknZKfOr2t/view?usp=sharing here]

The pull request can be accessed [https://github.com/expertiza/expertiza/pull/2321 here]

The forked git repository for this project can be found [https://github.com/atharva1996/expertiza here]

==Conclusion==

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-21T22:02:45Z

Sbose2:

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is the software benefits for both instructors and students by supporting various types of submissions and providing reusable objects for peer review. It is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. It allows the instructors not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams to work on various projects and assignments. Expertiza also lets students peer-review other students' submissions, enabling them to work together to improve others' learning experiences.

== Description about project ==
This page is a description of Expertiza OSS project E2202 which is adding test cases for badges_controller.rb and publishing_controller.rb. The badges controller allows users to create badges by entering the badge name, description and an image that serves as the badge icon. The publishing controller enables the students to grant/revoke publishing rights to past assignments. It does this by either allowing the students to grant and deny rights individually or all of them together. It makes use of the private key to verify the digital signature of the user granting the rights.

=== Files Involved ===

badges_controller.rb

badges_controller_spec.rb

publishing_controller.rb

publishing_controller_spec.rb

=== Running Tests ===

<pre>

rspec spec/controllers/publishing_controller_spec.rb spec/controllers/badges_controller_spec.rb

</pre>

== Test Plan ==
After setting up the development environment, we ran the original test cases for the badges_controller. However the test cases were very limited and only partially covered one of the methods. We wrote additional test cases to cover all the 5 methods badges controller and expanded the existing test case.
For the publishing_controller no tests were available so we had to write every test from scratch. We have written tests to cover all the 6 methods in the publishing_controller. In total we wrote 27 test cases for both the controllers. We used object mocking for creating the unit test cases.

====Badges Controller Methods====
The methods in the controller are:

*action_allowed?
*new
*redirect_to_assignment
*create
*badge_params

====Publishing Controller Methods====
The methods in the controller are:

*action_allowed?
*view
*set_publish_permission
*update_publish_permissions
*grant
*grant_with_private_key

====Test Frame for Badges Controller====

1. action_allowed? - When user tries to access the badges this method is called to check if the current user is authorized to view this page. All the users except the user with student privileges has access to perform actions in badges.

Code snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'refuses student from performing certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_falsey
end

it 'allows teaching assisstant to perform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. New - When user tries to create a new badge it redirects to the new create badge page and allow the user to enter details for the badge creation.

Code snippet:
<pre>
describe '#new' do
context 'when user wants to create a new badge' do
it 'should call the new#badge page url' do
get :new
expect(get: 'badges/new').to route_to('badges#new')
end

it 'should render the create new form and allow the user to enter details' do
allow(Badge).to receive(:new).and_return(badge)
params = {}
session = { user: instructor1 }
get :new, params, session
expect(response).to render_template('new')
end
end
end
</pre>

3. redirect_to_assignment - When the user has successfully created a badge it redirects to the assignment page.

Code Snippet:
<pre>
describe 'redirect_to_assignment' do
context 'after user successfully creates a badge' do
it 'calls the redirect_to_assignment url' do
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
expect(get: 'badges/redirect_to_assignment').to route_to('badges#redirect_to_assignment')
end

it 'redirects to the assignment page' do
stub_current_user(ta, ta.role.name, ta.role)
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
response.should redirect_to("http://test.host/assignments/844/edit")
end
end
end
</pre>

4. create - When the user tries to create a badge by entering all the required details, it saves the badge. If there are any missing required details for badge creation it throws an error for missing fields.

Code Snippet:
<pre>
describe '#create' do
context 'when user enters all the required badge details correctly' do
it 'should save the badge successfully' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to redirect_to 'http://test.host/assignments/844/edit'
end
end

context 'when user forgets to enter few of the required badge details' do
it 'should throw an error for missing image file' do
@file = nil
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge name' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: '',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge description' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: '',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end
end
end
</pre>

====Test Frame for Publishing Controller====

1. action_allowed? - When user tries to grant or view publishing rights this method is called to check if the current user is authorized to perform the action. All users with student privileges have access to perform actions for publishing.

Code Snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows student to perform certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows teaching assisstant to peform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. view - When user visits the publishing rights page, it displays all past assignment participants.

Code Snippet:
<pre>
describe 'view' do
context 'user visits the publishing rights page' do
it 'displays all the assignment participants' do
stub_current_user(student1, student1.role.name, student1.role)
params = { id: 21 }
get :view, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

3. set_publish_permission - When the user matches with the participant and the user clicks on the grant button next to the assignment, it redirects to the grant page.
When the user matches with the participant and the assignment is already granted permission, it redirects to the view page.

Code Snippet:
<pre>
describe 'set_publish_permission' do
context 'user matches with participant and user clicks on the grant button next to the assignment' do
it 'redirects to the grant page' do
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 1, allow: 1}
post :set_publish_permission, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user matches with participant and the assignment is already granted permission' do
it 'redirects to the view page' do
stub_current_user(student1, student1.role.name, student1.role)
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
allow(assignment_participant1).to receive(:update_attribute).and_return(true)
params ={id: 1, allow: '0'}
post :set_publish_permission, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

4. update_publish_permissions - When a user clicks on the grant publishing rights to all past assignments button it redirects to the grant page.
When a user clicks on the deny publishing rights to all past assignments button it redirects to the view page.

Code Snippet:
<pre>
describe 'update_publish_permissions' do
context 'user clicks on the grant publishing rights to all past assignments button' do
it 'redirects to grant page' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 1}
post :update_publish_permissions, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user clicks on the deny publishing rights to all past assignments button' do
it 'redirects to view page' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 0}
[assignment_participant1].each do |participant|
allow(participant).to receive(:update_attribute).and_return(true)
allow(participant).to receive(:save).and_return(true)
end
post :update_publish_permissions, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

5. grant - When a user clicks on the grant publishing option, it displays the page where the user can supply their private key and grant publishing rights.

Code Snippet:
<pre>
describe 'grant' do
context 'user clicks on grant option' do
it 'displays the page where the user can supply their private key and grant publishing rights' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3}
get :grant, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

6. grant_with_private_key - When a user visits the grant page without id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant page.
When a user visits the grant page with id and enters correct RSA private key, it verifies key to be successful for all past assignments and redirects to view page.
When a user visits the grant page with id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant.

Code Snippet:
<pre>
describe 'grant_with_private_key' do

context 'user visits the grant page without id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params = {}
private_key = double(:private_key)
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(private_key).and_return(true)
allow(participant).to receive(:assign_copyright).with(private_key).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant)
end
end

context 'user visits the grant page with id and enters correct RSA private key' do
it 'verifies to be successful for all past assignments and redirect to view' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_return(true)
end
post :grant_with_private_key, params
expect(response).to redirect_to(action: :view)
end
end

context 'user visits the grant page with id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant,params:{id:2})
end
end
end
</pre>

==Results==

The total coverage of the tests is 100%. We covered all the edges cases to ensure maximum coverage.

==Related Links==

A video of all the tests running can be found here [https://drive.google.com/file/d/1yKN_zzzkNGzkVpwnLCh_WPBknZKfOr2t/view?usp=sharing]

The pull request can be accessed here [https://github.com/expertiza/expertiza/pull/2321]

The forked git repository for this project can be found at [https://github.com/atharva1996/expertiza]

==Conclusion==

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-21T21:49:45Z

Sbose2: /* Test Frame for Publishing Controller */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is the software benefits for both instructors and students by supporting various types of submissions and providing reusable objects for peer review. It is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. It allows the instructors not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams to work on various projects and assignments. Expertiza also lets students peer-review other students' submissions, enabling them to work together to improve others' learning experiences.

== Description about project ==
This page is a description of Expertiza OSS project E2202 which is adding test cases for badges_controller.rb and publishing_controller.rb. The badges controller allows users to create badges by entering the badge name, description and an image that serves as the badge icon. The publishing controller enables the students to grant/revoke publishing rights to past assignments. It does this by either allowing the students to grant and deny rights individually or all of them together. It makes use of the private key to verify the digital signature of the user granting the rights.

=== Files Involved ===

badges_controller.rb

badges_controller_spec.rb

publishing_controller.rb

publishing_controller_spec.rb

=== Running Tests ===

<pre>

rspec spec/controllers/publishing_controller_spec.rb spec/controllers/badges_controller_spec.rb

</pre>

== Test Plan ==
After setting up the development environment, we ran the original test cases for the badges_controller. However the test cases were very limited and only partially covered one of the methods. We wrote additional test cases to cover all the 5 methods badges controller and expanded the existing test case.
For the publishing_controller no tests were available so we had to write every test from scratch. We have written tests to cover all the 6 methods in the publishing_controller. In total we wrote 27 test cases for both the controllers. We used object mocking for creating the unit test cases.

====Badges Controller Methods====
The methods in the controller are:

*action_allowed?
*new
*redirect_to_assignment
*create
*badge_params

====Publishing Controller Methods====
The methods in the controller are:

*action_allowed?
*view
*set_publish_permission
*update_publish_permissions
*grant
*grant_with_private_key

====Test Frame for Badges Controller====

1. action_allowed? - When user tries to access the badges this method is called to check if the current user is authorized to view this page. All the users except the user with student privileges has access to perform actions in badges.

Code snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'refuses student from performing certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_falsey
end

it 'allows teaching assisstant to perform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. New - When user tries to create a new badge it redirects to the new create badge page and allow the user to enter details for the badge creation.

Code snippet:
<pre>
describe '#new' do
context 'when user wants to create a new badge' do
it 'should call the new#badge page url' do
get :new
expect(get: 'badges/new').to route_to('badges#new')
end

it 'should render the create new form and allow the user to enter details' do
allow(Badge).to receive(:new).and_return(badge)
params = {}
session = { user: instructor1 }
get :new, params, session
expect(response).to render_template('new')
end
end
end
</pre>

3. redirect_to_assignment - When the user has successfully created a badge it redirects to the assignment page.

Code Snippet:
<pre>
describe 'redirect_to_assignment' do
context 'after user successfully creates a badge' do
it 'calls the redirect_to_assignment url' do
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
expect(get: 'badges/redirect_to_assignment').to route_to('badges#redirect_to_assignment')
end

it 'redirects to the assignment page' do
stub_current_user(ta, ta.role.name, ta.role)
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
response.should redirect_to("http://test.host/assignments/844/edit")
end
end
end
</pre>

4. create - When the user tries to create a badge by entering all the required details, it saves the badge. If there are any missing required details for badge creation it throws an error for missing fields.

Code Snippet:
<pre>
describe '#create' do
context 'when user enters all the required badge details correctly' do
it 'should save the badge successfully' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to redirect_to 'http://test.host/assignments/844/edit'
end
end

context 'when user forgets to enter few of the required badge details' do
it 'should throw an error for missing image file' do
@file = nil
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge name' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: '',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge description' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: '',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end
end
end
</pre>

====Test Frame for Publishing Controller====

1. action_allowed? - When user tries to grant or view publishing rights this method is called to check if the current user is authorized to perform the action. All users with student privileges have access to perform actions for publishing.

Code Snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows student to perform certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows teaching assisstant to peform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. view - When user visits the publishing rights page, it displays all past assignment participants.

Code Snippet:
<pre>
describe 'view' do
context 'user visits the publishing rights page' do
it 'displays all the assignment participants' do
stub_current_user(student1, student1.role.name, student1.role)
params = { id: 21 }
get :view, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

3. set_publish_permission - When the user matches with the participant and the user clicks on the grant button next to the assignment, it redirects to the grant page.
When the user matches with the participant and the assignment is already granted permission, it redirects to the view page.

Code Snippet:
<pre>
describe 'set_publish_permission' do
context 'user matches with participant and user clicks on the grant button next to the assignment' do
it 'redirects to the grant page' do
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 1, allow: 1}
post :set_publish_permission, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user matches with participant and the assignment is already granted permission' do
it 'redirects to the view page' do
stub_current_user(student1, student1.role.name, student1.role)
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
allow(assignment_participant1).to receive(:update_attribute).and_return(true)
params ={id: 1, allow: '0'}
post :set_publish_permission, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

4. update_publish_permissions - When a user clicks on the grant publishing rights to all past assignments button it redirects to the grant page.
When a user clicks on the deny publishing rights to all past assignments button it redirects to the view page.

Code Snippet:
<pre>
describe 'update_publish_permissions' do
context 'user clicks on the grant publishing rights to all past assignments button' do
it 'redirects to grant page' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 1}
post :update_publish_permissions, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user clicks on the deny publishing rights to all past assignments button' do
it 'redirects to view page' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 0}
[assignment_participant1].each do |participant|
allow(participant).to receive(:update_attribute).and_return(true)
allow(participant).to receive(:save).and_return(true)
end
post :update_publish_permissions, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

5. grant - When a user clicks on the grant publishing option, it displays the page where the user can supply their private key and grant publishing rights.

Code Snippet:
<pre>
describe 'grant' do
context 'user clicks on grant option' do
it 'displays the page where the user can supply their private key and grant publishing rights' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3}
get :grant, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

6. grant_with_private_key - When a user visits the grant page without id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant page.
When a user visits the grant page with id and enters correct RSA private key, it verifies key to be successful for all past assignments and redirects to view page.
When a user visits the grant page with id and enters incorrect RSA private key, it throws StandardError, displays notice and redirects to grant.

Code Snippet:
<pre>
describe 'grant_with_private_key' do

context 'user visits the grant page without id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params = {}
private_key = double(:private_key)
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(private_key).and_return(true)
allow(participant).to receive(:assign_copyright).with(private_key).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant)
end
end

context 'user visits the grant page with id and enters correct RSA private key' do
it 'verifies to be successful for all past assignments and redirect to view' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_return(true)
end
post :grant_with_private_key, params
expect(response).to redirect_to(action: :view)
end
end

context 'user visits the grant page with id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant,params:{id:2})
end
end
end
</pre>

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-21T21:47:40Z

Sbose2:

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is the software benefits for both instructors and students by supporting various types of submissions and providing reusable objects for peer review. It is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. It allows the instructors not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams to work on various projects and assignments. Expertiza also lets students peer-review other students' submissions, enabling them to work together to improve others' learning experiences.

== Description about project ==
This page is a description of Expertiza OSS project E2202 which is adding test cases for badges_controller.rb and publishing_controller.rb. The badges controller allows users to create badges by entering the badge name, description and an image that serves as the badge icon. The publishing controller enables the students to grant/revoke publishing rights to past assignments. It does this by either allowing the students to grant and deny rights individually or all of them together. It makes use of the private key to verify the digital signature of the user granting the rights.

=== Files Involved ===

badges_controller.rb

badges_controller_spec.rb

publishing_controller.rb

publishing_controller_spec.rb

=== Running Tests ===

<pre>

rspec spec/controllers/publishing_controller_spec.rb spec/controllers/badges_controller_spec.rb

</pre>

== Test Plan ==
After setting up the development environment, we ran the original test cases for the badges_controller. However the test cases were very limited and only partially covered one of the methods. We wrote additional test cases to cover all the 5 methods badges controller and expanded the existing test case.
For the publishing_controller no tests were available so we had to write every test from scratch. We have written tests to cover all the 6 methods in the publishing_controller. In total we wrote 27 test cases for both the controllers. We used object mocking for creating the unit test cases.

====Badges Controller Methods====
The methods in the controller are:

*action_allowed?
*new
*redirect_to_assignment
*create
*badge_params

====Publishing Controller Methods====
The methods in the controller are:

*action_allowed?
*view
*set_publish_permission
*update_publish_permissions
*grant
*grant_with_private_key

====Test Frame for Badges Controller====

1. action_allowed? - When user tries to access the badges this method is called to check if the current user is authorized to view this page. All the users except the user with student privileges has access to perform actions in badges.

Code snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'refuses student from performing certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_falsey
end

it 'allows teaching assisstant to perform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. New - When user tries to create a new badge it redirects to the new create badge page and allow the user to enter details for the badge creation.

Code snippet:
<pre>
describe '#new' do
context 'when user wants to create a new badge' do
it 'should call the new#badge page url' do
get :new
expect(get: 'badges/new').to route_to('badges#new')
end

it 'should render the create new form and allow the user to enter details' do
allow(Badge).to receive(:new).and_return(badge)
params = {}
session = { user: instructor1 }
get :new, params, session
expect(response).to render_template('new')
end
end
end
</pre>

3. redirect_to_assignment - When the user has successfully created a badge it redirects to the assignment page.

Code Snippet:
<pre>
describe 'redirect_to_assignment' do
context 'after user successfully creates a badge' do
it 'calls the redirect_to_assignment url' do
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
expect(get: 'badges/redirect_to_assignment').to route_to('badges#redirect_to_assignment')
end

it 'redirects to the assignment page' do
stub_current_user(ta, ta.role.name, ta.role)
session[:return_to] ||= 'http://test.host/assignments/844/edit'
get :redirect_to_assignment
response.should redirect_to("http://test.host/assignments/844/edit")
end
end
end
</pre>

4. create - When the user tries to create a badge by entering all the required details, it saves the badge. If there are any missing required details for badge creation it throws an error for missing fields.

Code Snippet:
<pre>
describe '#create' do
context 'when user enters all the required badge details correctly' do
it 'should save the badge successfully' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to redirect_to 'http://test.host/assignments/844/edit'
end
end

context 'when user forgets to enter few of the required badge details' do
it 'should throw an error for missing image file' do
@file = nil
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge name' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: '',
description: 'test badge',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end

it 'should throw an error for missing badge description' do
@file = fixture_file_upload('app/assets/images/badges/test.png', 'image/png')
allow(@file).to receive(:original_filename).and_return("test.png")
session = { user: instructor1 }
params = {
badge:{
name: 'test',
description: '',
image_name: 'test.png',
image_file: @file
}
}
session[:return_to] ||= 'http://test.host/assignments/844/edit'
allow(Badge).to receive(:get_id_from_name).with('test').and_return(badge)
allow(Badge).to receive(:get_image_name_from_name).with('test').and_return(badge)
post :create, params, session, "file" => @file
expect(response).to render_template('new')
end
end
end
</pre>

====Test Frame for Publishing Controller====

1. action_allowed? - When user tries to grant or view publishing rights this method is called to check if the current user is authorized to perform the action. All users with student privileges have access to perform actions for publishing.

Code Snippet:
<pre>
describe '#action_allowed?' do
it 'allows super_admin to perform certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows instructor to perform certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows student to perform certain action' do
stub_current_user(student1, student1.role.name, student1.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows teaching assisstant to peform certain action' do
stub_current_user(ta, ta.role.name, ta.role)
expect(controller.send(:action_allowed?)).to be_truthy
end

it 'allows admin to perform certain action' do
stub_current_user(admin, admin.role.name, admin.role)
expect(controller.send(:action_allowed?)).to be_truthy
end
end
</pre>

2. view - When user visits the publishing rights page, it displays all past assignment participants.

Code Snippet:
<pre>
describe 'view' do
context 'user visits the publishing rights page' do
it 'displays all the assignment participants' do
stub_current_user(student1, student1.role.name, student1.role)
params = { id: 21 }
get :view, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

3. set_publish_permission - When the user matches with the participant and the user clicks on the grant button next to the assignment, it redirects to the grant page.
When the user matches with the participant and the assignment is already granted permission, it redirects to the view page.

Code Snippet:
<pre>
describe 'set_publish_permission' do
context 'user matches with participant and user clicks on the grant button next to the assignment' do
it 'redirects to the grant page' do
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 1, allow: 1}
post :set_publish_permission, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user matches with participant and the assignment is already granted permission' do
it 'redirects to the view page' do
stub_current_user(student1, student1.role.name, student1.role)
allow(AssignmentParticipant).to receive(:find).with('1').and_return(assignment_participant1)
allow(assignment_participant1).to receive(:update_attribute).and_return(true)
params ={id: 1, allow: '0'}
post :set_publish_permission, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

4. update_publish_permissions - When a user clicks on the grant publishing rights to all past assignments button it redirects to the grant page.
When a user clicks on the deny publishing rights to all past assignments button it redirects to the view page.

Code Snippet:
<pre>
describe 'update_publish_permissions' do
context 'user clicks on the grant publishing rights to all past assignments button' do
it 'redirects to grant page' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 1}
post :update_publish_permissions, params
expect(response).to redirect_to(action: :grant)
end
end

context 'user clicks on the deny publishing rights to all past assignments button' do
it 'redirects to view page' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3, allow: 0}
[assignment_participant1].each do |participant|
allow(participant).to receive(:update_attribute).and_return(true)
allow(participant).to receive(:save).and_return(true)
end
post :update_publish_permissions, params
expect(response).to redirect_to(action: :view)
end
end
end
</pre>

5. grant - When a user clicks on the grant publishing option, it displays the page where the user can supply their private key and grant publishing rights.

Code Snippet:
<pre>
describe 'grant' do
context 'user clicks on grant option' do
it 'displays the page where the user can supply their private key and grant publishing rights' do
allow(AssignmentParticipant).to receive(:find).with('3').and_return(assignment_participant2)
stub_current_user(student1, student1.role.name, student1.role)
params ={id: 3}
get :grant, params
expect(assigns(:user)).to eq(student1)
end
end
end
</pre>

6. grant_with_private_key - When a user visits the grant page without id and enters incorrect RSA private key, it displays notice and redirects to grant page.
When a user visits the grant page with id and enters correct RSA private key, it verifies key to be successful for all past assignments and redirects to view page.
When a user visits the grant page with id and enters incorrect RSA private key, it displays notice and redirects to grant.

Code Snippet:
<pre>
describe 'grant_with_private_key' do

context 'user visits the grant page without id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:where).with(user_id: 21).and_return([assignment_participant1])
stub_current_user(student1, student1.role.name, student1.role)
params = {}
private_key = double(:private_key)
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(private_key).and_return(true)
allow(participant).to receive(:assign_copyright).with(private_key).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant)
end
end

context 'user visits the grant page with id and enters correct RSA private key' do
it 'verifies to be successful for all past assignments and redirect to view' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_return(true)
end
post :grant_with_private_key, params
expect(response).to redirect_to(action: :view)
end
end

context 'user visits the grant page with id and enters incorrect RSA private key' do
it 'displays notice and redirects to grant' do
allow(AssignmentParticipant).to receive(:find).with('2').and_return(assignment_participant1)
stub_current_user(student1, student1.role.name, student1.role)
private_key = OpenSSL::PKey::RSA.new 2048
params = {id: 2, private_key: private_key}
[assignment_participant1].each do |participant|
allow(participant).to receive(:verify_digital_signature).with(any_args).and_return(true)
allow(participant).to receive(:assign_copyright).with(any_args).and_raise('The private key you inputted was invalid.', StandardError)
end
post :grant_with_private_key, params
expect(flash[:notice]).to eq('The private key you inputted was invalid.')
expect(response).to redirect_to(action: :grant,params:{id:2})
end
end
end
</pre>

CSC/ECE 517 Spring 2022 - E2202- Testing for badges controller, publishing controller

2022-03-21T21:28:24Z

Sbose2: