Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-30T05:03:50Z

Lshyu: /* Links */

==Project Overview==
===Background===
To improve the experience of peer-reviewing in Expertiza and determine the competent reviewers amongst all the reviewers, creating a new form of review for assignments was considered. As a result, "calibration assignments" were introduced to the Expertiza system. The calibration assignments were to be assigned before peer review occurred so that students would know if they reviewed the same way that the instructor had reviewed the assignment. Calibration assignments show whether or not the student had given the same or similar score as the instructor for rubric items.

To set up a calibration assignment that both the instructor and the course students can review, the instructor needs to create a new assignment, add the extra participant manually, impersonate the participant, and finally, submit the review, which is not a great experience. What's more is that currently, if an instructor wishes to do this every semester or every year with the same course to copy over the calibration assignments, they have to repeat this process yet again.

===Objectives===
Expertiza can fix the problem of repeatedly setting up the calibration assignments by automatically copying the previous calibration assignments with all attached reviews.

===Previous Implementation===
In the previous implementation, the implementors designed the calibration review as part of the assignment and students were able to participate in calibration review training before reviewing other students' work.

The instructor can enable the calibration review in two ways:

====1. Check "Calibration for training?" in the general tab of an assignment then copy the participants from the course.====

[[File:2021-11-03 011751.png]]

====2. Copy existing assignment and its participants with calibration review enabled.====

Detailed System Overview can be found at the following: 
[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

However, their implementation introduced several assumptions about the system that we will address to allow merging into production.

===Issues with the Previous work===
#The project assumes that calibration submissions starts at directory 0, which is only correct if the users who submit the calibration submissions are the first to be added as participants to the assignment.
##Suggested Fix: set submitter_count to the largest directory number that Expertiza used for calibration.
###Allows us to keep track of the most recent calibration submission.
###Gives us something we can reference during copying to get the correct directory.
#The due date of calibration review are missing. [[File:2021-11-03 235457.png]]
#The copied assignments do not have participants copied. [[File:2021-11-04 013403.png]]

==Design==
#TODO: add UML diagram, preliminary class design
[[File:2021-11-04 230435.png]]

==Implementation==
===Files we originally planned to modify===
#app/controllers/student_review_controller.rb The mappings of reviews or calibration reviews should be redesigned.
#views/student_review/list.html.erb The view of the list should be modified so that the calibration review can be displayed correctly.
#views/assignments/edit/_due_dates.html.erb 
#app/models/deadline_right.rb
#app/controllers/assignments_controller.rb The assignments_controller might need a fix so that the assignments with calibration review can be deleted properly.
#app/views/student_review/_responses.html.erb

===Files we modified===
#app/models/assignment_form.rb
##Removed vary_by_topic_desired from the update function.
##Removed topic references from update_assignment_questionnaires.
##Updated Questionnaire to AssignmentQuestionnaire.
##Added self.copy_calibration function.
##Updated the copy counter.
#app/models/assignment_team.rb
##Removed code for E1973.
##Updated review response map return.
##Created directory_path function.
#app/models/deadline_right.rb
##Added calibration to the model.
#app/models/participant.rb
##Added self.createparticipant function.
#app/models/review_response_map.rb
##Removed E1973 code.
##Removed topic from questionnaire function.
##Shortened self.import function.
##Added self.newreviewresp function.
#app/models/submission_record.rb
##Added self.copycalibratedsubmissions function.
#app/models/team.rb
##Added self.createnewteam function.
#app/views/assignments/edit/_due_dates.html.erb
##Added checkmark for calibration.
#spec/features/assignment_creation_general_tab_spec.rb
##See tests section.
#spec/models/assignment_form_spec.rb
##See tests section.
#db/migrate/20211129124620_add_calibration_to_deadline_type.rb
##We added a new migration for AddCalibrationToDeadlineType.
#Screenshots:
[[File:2021-11-29 235044.png]]
[[File:2021-11-29 235328.png]]
[[File:2021-11-29 235441.png]]
[[File:2021-11-29 235827.png]]
[[File:2021-11-29 235912.png]]

==Testing Plan==

#Unit test files added:
##spec/models/assignment_form_spec.rb
###Added tests for function 'copy'. Test to make sure that the assignment id is updated on copy and no longer references the original assignment. We also make sure that the name of the new file is correct.
##spec/features/assignment_creation_general_tab_spec.rb
###Added unit test to make sure that the calibration shows in the due dates tab.

Testing scenarios:

#The instructor copies the existing assignment The copied assignment stored in the correct directory Expect the number of calibration submitters of the copied assignment=the number of participants of the original assignment
#The instructor enables the calibration review of an assignment The calibration tab appears next to the due dates tab
#The student attempts his/her calibration review The student submits the calibration review The webpage shows what the student has submitted as well as a long that says "Show Calibration Results".

==Errors Found==

We found, and fixed, a bug in app/controllers/response_controller.rb where the code was using get_reviewer instead of reviewer. We needed to fix this bug in order for our code to work.

==Future Improvements==

We believe that submitter_count can be removed from the database since it is never used in the project and in order to update the student directory number we do set_student_directory_num on any of team object within an assignment.

==Links==
[https://github.com/Kasimir123/expertiza/tree/beta Github repository]

[https://youtu.be/_53Zyyz59q0 Demonstration]

==Team==
#John Marsden (ProfDoof)
#Lee Shyu (ls-hyu)
#Angela Ho (angelaho0504)
#Kasimir Schulz (Kasimir123)

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-30T05:00:05Z

Lshyu: /* Files we modified */

==Project Overview==
===Background===
To improve the experience of peer-reviewing in Expertiza and determine the competent reviewers amongst all the reviewers, creating a new form of review for assignments was considered. As a result, "calibration assignments" were introduced to the Expertiza system. The calibration assignments were to be assigned before peer review occurred so that students would know if they reviewed the same way that the instructor had reviewed the assignment. Calibration assignments show whether or not the student had given the same or similar score as the instructor for rubric items.

To set up a calibration assignment that both the instructor and the course students can review, the instructor needs to create a new assignment, add the extra participant manually, impersonate the participant, and finally, submit the review, which is not a great experience. What's more is that currently, if an instructor wishes to do this every semester or every year with the same course to copy over the calibration assignments, they have to repeat this process yet again.

===Objectives===
Expertiza can fix the problem of repeatedly setting up the calibration assignments by automatically copying the previous calibration assignments with all attached reviews.

===Previous Implementation===
In the previous implementation, the implementors designed the calibration review as part of the assignment and students were able to participate in calibration review training before reviewing other students' work.

The instructor can enable the calibration review in two ways:

====1. Check "Calibration for training?" in the general tab of an assignment then copy the participants from the course.====

[[File:2021-11-03 011751.png]]

====2. Copy existing assignment and its participants with calibration review enabled.====

Detailed System Overview can be found at the following: 
[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

However, their implementation introduced several assumptions about the system that we will address to allow merging into production.

===Issues with the Previous work===
#The project assumes that calibration submissions starts at directory 0, which is only correct if the users who submit the calibration submissions are the first to be added as participants to the assignment.
##Suggested Fix: set submitter_count to the largest directory number that Expertiza used for calibration.
###Allows us to keep track of the most recent calibration submission.
###Gives us something we can reference during copying to get the correct directory.
#The due date of calibration review are missing. [[File:2021-11-03 235457.png]]
#The copied assignments do not have participants copied. [[File:2021-11-04 013403.png]]

==Design==
#TODO: add UML diagram, preliminary class design
[[File:2021-11-04 230435.png]]

==Implementation==
===Files we originally planned to modify===
#app/controllers/student_review_controller.rb The mappings of reviews or calibration reviews should be redesigned.
#views/student_review/list.html.erb The view of the list should be modified so that the calibration review can be displayed correctly.
#views/assignments/edit/_due_dates.html.erb 
#app/models/deadline_right.rb
#app/controllers/assignments_controller.rb The assignments_controller might need a fix so that the assignments with calibration review can be deleted properly.
#app/views/student_review/_responses.html.erb

===Files we modified===
#app/models/assignment_form.rb
##Removed vary_by_topic_desired from the update function.
##Removed topic references from update_assignment_questionnaires.
##Updated Questionnaire to AssignmentQuestionnaire.
##Added self.copy_calibration function.
##Updated the copy counter.
#app/models/assignment_team.rb
##Removed code for E1973.
##Updated review response map return.
##Created directory_path function.
#app/models/deadline_right.rb
##Added calibration to the model.
#app/models/participant.rb
##Added self.createparticipant function.
#app/models/review_response_map.rb
##Removed E1973 code.
##Removed topic from questionnaire function.
##Shortened self.import function.
##Added self.newreviewresp function.
#app/models/submission_record.rb
##Added self.copycalibratedsubmissions function.
#app/models/team.rb
##Added self.createnewteam function.
#app/views/assignments/edit/_due_dates.html.erb
##Added checkmark for calibration.
#spec/features/assignment_creation_general_tab_spec.rb
##See tests section.
#spec/models/assignment_form_spec.rb
##See tests section.
#db/migrate/20211129124620_add_calibration_to_deadline_type.rb
##We added a new migration for AddCalibrationToDeadlineType.
#Screenshots:
[[File:2021-11-29 235044.png]]
[[File:2021-11-29 235328.png]]
[[File:2021-11-29 235441.png]]
[[File:2021-11-29 235827.png]]
[[File:2021-11-29 235912.png]]

==Testing Plan==

#Unit test files added:
##spec/models/assignment_form_spec.rb
###Added tests for function 'copy'. Test to make sure that the assignment id is updated on copy and no longer references the original assignment. We also make sure that the name of the new file is correct.
##spec/features/assignment_creation_general_tab_spec.rb
###Added unit test to make sure that the calibration shows in the due dates tab.

Testing scenarios:

#The instructor copies the existing assignment The copied assignment stored in the correct directory Expect the number of calibration submitters of the copied assignment=the number of participants of the original assignment
#The instructor enables the calibration review of an assignment The calibration tab appears next to the due dates tab
#The student attempts his/her calibration review The student submits the calibration review The webpage shows what the student has submitted as well as a long that says "Show Calibration Results".

==Errors Found==

We found, and fixed, a bug in app/controllers/response_controller.rb where the code was using get_reviewer instead of reviewer. We needed to fix this bug in order for our code to work.

==Future Improvements==

We believe that submitter_count can be removed from the database since it is never used in the project and in order to update the student directory number we do set_student_directory_num on any of team object within an assignment.

==Links==
[https://github.com/Kasimir123/expertiza/tree/beta Github repository]

==Team==
#John Marsden (ProfDoof)
#Lee Shyu (ls-hyu)
#Angela Ho (angelaho0504)
#Kasimir Schulz (Kasimir123)

File:2021-11-29 235912.png

2021-11-30T04:59:35Z

Lshyu:

File:2021-11-29 235827.png

2021-11-30T04:58:41Z

Lshyu:

File:2021-11-29 235441.png

2021-11-30T04:54:56Z

Lshyu:

File:2021-11-29 235328.png

2021-11-30T04:53:44Z

Lshyu:

File:2021-11-29 235044.png

2021-11-30T04:51:02Z

Lshyu:

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-09T03:28:32Z

Lshyu: /* Implementation */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-05T03:06:00Z

Lshyu: /* Design */

File:2021-11-04 230435.png

2021-11-05T03:05:18Z

Lshyu:

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T21:45:01Z

Lshyu: /* Testing Plan */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T21:30:38Z

Lshyu: /* Testing Plan */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T21:13:39Z

Lshyu: /* Testing Plan */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T19:38:33Z

Lshyu: /* Testing Plan */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T05:47:30Z

Lshyu:

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T05:43:46Z

Lshyu:

File:2021-11-04 013403.png

2021-11-04T05:42:35Z

Lshyu:

File:2021-11-03 235457.png

2021-11-04T05:34:31Z

Lshyu: Lshyu uploaded a new version of File:2021-11-03 235457.png

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T05:18:57Z

Lshyu: /* Previous Implementation */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T05:16:52Z

Lshyu: /* Previous Implementation */

File:2021-11-03 235457.png

2021-11-04T03:55:25Z

Lshyu:

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-04T03:31:11Z

Lshyu:

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T15:31:20Z

Lshyu: /* Introduction */

==Project Overview==
===Introduction===
#TODO: Rephrase the sentences
Expertiza is an open-source learning management system developed using Ruby on Rails framework. Expertiza supports multiple features such as course management, assignment submission, peer review, grade calculation, etc.

[https://expertiza.csc.ncsu.edu/index.php/Expertiza_documentation Expertiza Documentation]

[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===
In the previous implementation, the calibration review was designed as part of the assignment and students should be able to participate in calibration review training before reviewing other students' work.

The instructor can enable the calibration review in each assignment by checking the box before "Calibration for training?".

[[File:2021-11-03 011751.png]]

[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

===Issues of Previous work===
#If any student submits a review before completing the calibration review training, the first review submitted will be stored at directory 0, where the calibration review was supposed to be stored.
#

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T05:22:21Z

Lshyu: /* Introduction */

==Project Overview==
===Introduction===
#TODO: Rephrase the sentences
[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===
In the previous implementation, the calibration review was designed as part of the assignment and students should be able to participate in calibration review training before reviewing other students' work.

The instructor can enable the calibration review in each assignment by checking the box before "Calibration for training?".

[[File:2021-11-03 011751.png]]

[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

===Issues of Previous work===
#If any student submits a review before completing the calibration review training, the first review submitted will be stored at directory 0, where the calibration review was supposed to be stored.
#

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T05:19:51Z

Lshyu: /* Previous Implementation */

==Project Overview==
===Introduction===
[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===
In the previous implementation, the calibration review was designed as part of the assignment and students should be able to participate in calibration review training before reviewing other students' work.

The instructor can enable the calibration review in each assignment by checking the box before "Calibration for training?".

[[File:2021-11-03 011751.png]]

[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

===Issues of Previous work===
#If any student submits a review before completing the calibration review training, the first review submitted will be stored at directory 0, where the calibration review was supposed to be stored.
#

==Design==

==Implementation==

File:2021-11-03 011751.png

2021-11-03T05:18:31Z

Lshyu:

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T05:18:03Z

Lshyu: /* Previous Implementation */

==Project Overview==
===Introduction===
[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===
In the previous implementation, the calibration review was designed as part of the assignment and students should be able to participate in calibration review training before reviewing other students' work.

The instructor can enable the calibration review in each assignment by checking the box before "Calibration for training?".

[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

===Issues of Previous work===
#If any student submits a review before completing the calibration review training, the first review submitted will be stored at directory 0, where the calibration review was supposed to be stored.
#

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T05:13:02Z

Lshyu: /* Previous Implementation */

==Project Overview==
===Introduction===
[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===
In the previous implementation, the calibration review was designed as part of the assignment and students should be able to participate in calibration review training before reviewing other students' work.

[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

===Issues of Previous work===
#If any student submits a review before completing the calibration review training, the first review submitted will be stored at directory 0, where the calibration review was supposed to be stored.
#

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T05:08:52Z

Lshyu: /* Issues of Previous work */

==Project Overview==
===Introduction===
[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===
[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

===Issues of Previous work===
#If any student submits a review before completing the calibration review training, the first review submitted will be stored at directory 0, where the calibration review was supposed to be stored.
#

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T05:00:51Z

Lshyu: /* Previous Implementation */

==Project Overview==
===Introduction===
[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===
[https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2017/E17A4_Allow_calibration_to_be_part_of_an_assignment CSC/ECE 517 Fall 2017/E17A4 Allow calibration to be part of an assignment]

===Issues of Previous work===

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T04:59:03Z

Lshyu: /* Objectives */

==Project Overview==
===Introduction===
[https://expertiza.ncsu.edu/ Expertiza] is an open-source education and classroom web-tool founded by the [http://www.nsf.gov/ National Science Foundation]. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.

===Background===
To improve the experience of peer reviewing and to find out the competent reviewers among all the reviewers, designing a new form of review for assignments seems to be a fix. As a result, "calibration assignment" was introduced to the Expertiza system. The calibration assignment should be assigned before the peer review so that the students can know if they reviewed using the same rubrics as the instructor.
To set up the calibration assignment that allows both the instructor and the students of the course to review, the instructor needs to create a new assignment and add the extra participant manually, impersonate the participant then submit the review, which is not a great experience.

===Objectives===
To fix the issue of setting up the calibration assignment repeatedly every semester, the system should be able to make a copy of the previous calibration assignment and let the instructor submit a review as the extra participant by selecting calibration training when the instructor creates the assignment.

===Previous Implementation===

===Issues of Previous work===

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T04:39:06Z

Lshyu: /* Background */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T04:37:41Z

Lshyu: /* Objectives */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T03:05:54Z

Lshyu: /* Background */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T02:59:46Z

Lshyu: /* Objectives */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T02:56:20Z

Lshyu: /* Project Overview */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T01:54:10Z

Lshyu: /* Project Overview */

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-03T01:53:42Z

Lshyu: /* Project Overview */

==Project Overview==
===Introduction===
Expertiza is an open-source education and classroom web-tool founded by the National Science Foundation. Built with Ruby on Rails, it is designed to manage complete courses and students’ work within those courses. Each course can have a collection of instructors and students, though the interaction between instructors and students is minimal. The real emphasis of Expertiza is placed on peer-to-peer interactions, fostering a student-driven learning environment. Courses are comprised of assignments which users complete individually or with a team. Assignments usually encourage or require a team to enforce practicing peer-to-peer interaction.
===Background===

===Objectives===

===Previous Implementation===

===Issues of Previous work===

==Design==

==Implementation==

CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments

2021-11-02T20:55:37Z

Lshyu: Created page with "==Project Overview== === ''Background'' === === ''Objectives'' === === ''Previous Implementation'' === === ''Issues of Previous work'' === ==Design==..."

==Project Overview==
=== ''Background'' ===

=== ''Objectives'' ===

=== ''Previous Implementation'' ===

=== ''Issues of Previous work'' ===

==Design==

==Implementation==

CSC/ECE 517 Fall 2021

2021-11-02T20:41:48Z

Lshyu: /* Final Projects */

== OSS Projects ==

* [[CSC/ECE 517 Fall 2021 - E2117. Refactor questionaires_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2128. Refactor student_quizzes_controller.rb & late_policies_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2129. Refactor auth_controller.rb & password_retrieval_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2132. Add tests cases for review mapping helper.rb]]
* [[CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin_controller.rb and institution_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2138. Auto-generate submission directory names based on assignment]]
* [[CSC/ECE 517 Fall 2021 - E2142. Improve e-mail notifications]]
* [[CSC/ECE 517 Fall 2021 - E2133. Write tests for popup_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2120. Refactor reputation_web_service_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2139. Remove multiple topics at a time]]
* [[CSC/ECE 517 Fall 2021 - E2131. Improve assessment360_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2121. Refactor suggestion_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2122. Refactor impersonate_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2123. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2126. Refactor account_request_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2124. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2125. Refactor review_mapping_helper.rb]]
* [[CSC/ECE 517 Fall 2021 - E2127. Refactor teams_controller]]
* [[CSC/ECE 517 Fall 2021 - E2130. Refactor submitted_content_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2140. Create new late policy successfully and fix Bank link]]
* [[CSC/ECE 517 Fall 2021 - E2141. OSS project Finklestein: Instructors & Institutions]]
* [[CSC/ECE 517 Fall 2021 - E2144. Refactor delayed mailer and scheduled task]]
* [[CSC/ECE 517 Fall 2021 - E2147. Role-based reviewing]]
* [[CSC/ECE 517 Fall 2021 - E2145. OSS Project Beige]]
* [[CSC/ECE 517 Fall 2021 - E2146. Introduce a Student View for instructors]]
* [[CSC/ECE 517 Fall 2021 - Refactor Evaluation of SQL Queries]]
* [[CSC/ECE 517 Fall 2021 - E2135. Email notification to reviewers and instructors]]
* [[CSC/ECE 517 Fall 2021 - E2168. Testing - Reputations]]
* [[CSC/ECE 517 Fall 2021 - E2166. Testing - Scoring & Grades]]
* [[CSC/ECE 517 Fall 2021 - E2149. Finish Github metrics integration - Reputations]]

== Final Projects ==
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2150._Integrate_suggestion_detection_algorithm#Description_about_project CSC/ECE 517 Fall 2021 - E2150. Integrate suggestion detection algorithm]
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2152._Revision_planning_tool#Description_about_project CSC/ECE 517 Fall 2021 - E2152. Revision_planning_tool]
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2170._Testing_-_Response_Maps#Description_about_project CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps]
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2153._Improving_search_facility_in_Expertiza#Description_about_project CSC/ECE 517 Fall 2021 - E2153. Improving search facility in Expertiza]
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2162._Further_refactoring_and_improvement_of_review_mapping_helper CSC/ECE 517 Fall 2021 - E2162. Further refactoring and improvement of review mapping helper]
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2165._Fix_teammate-review_view CSC/ECE 517 Fall 2021 - E2165. Fix teammate review view ]
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2158._Grading_audit_trail CSC/ECE 517 Fall 2021 - E2158. Grading audit trail ]
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2155._Calibration_submissions_should_be_copied_along_with_calibration_assignments CSC/ECE 517 Fall 2021 - E2155. Calibration submissions should be copied along with calibration assignments]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T19:05:01Z

Lshyu: /* Our Team */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'test institution'

==== Role 1: Admin ====
:admin
*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

==== Role 2: Instructor ====
:instructor, id: 6
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
#Delete an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: TA ====
:teaching_assistant, id: 8
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====
:student
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end
end
context 'when current user is the students' do
it 'deny certain action' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
stub_current_user(instructor, instructor.role.name, instructor.role)
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(flash.now[:success]).to eq('The institution was successfully created.')
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page and returns an error message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
# make save function always return false
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(flash[:success]).to eq('The institution was successfully updated.')
expect(response).to redirect_to("/institution/list")
end
end
context 'when institution is not updated successfully' do
it 'renders institution#edit' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
allow(institution).to receive(:update_attribute).with(any_args).and_return(false)
put :update, @params
expect(response).to render_template(:edit)
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1
}
# mock a situation that delete action successfully
allow(institution).to receive(:destroy).with(any_args).and_return(true)
post :delete, @params
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://www.youtube.com/watch?v=OZaaVLBul6Y&list=PLaoBe-cpzKA6Eq9xSogYiatOcOeSoRLQN&index=1 click here]

Demo of institution_controller_spec [https://www.youtube.com/watch?v=A1vuITGSRBI&list=PLaoBe-cpzKA6Eq9xSogYiatOcOeSoRLQN&index=2 click here]

== Our Team ==
*Yu-Hsuan Lo (ylo) (githubID: [https://github.com/yhslo yhslo])

*Chao-Ting Hung (chung4) (githubID: [https://github.com/gggho0806 gggho0806])

*Lee Shyu (lshyu) (githubID: [https://github.com/ls-hyu ls-hyu])

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T19:02:04Z

Lshyu: /* Our Team */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'test institution'

==== Role 1: Admin ====
:admin
*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

==== Role 2: Instructor ====
:instructor, id: 6
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
#Delete an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: TA ====
:teaching_assistant, id: 8
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====
:student
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end
end
context 'when current user is the students' do
it 'deny certain action' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
stub_current_user(instructor, instructor.role.name, instructor.role)
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(flash.now[:success]).to eq('The institution was successfully created.')
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page and returns an error message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
# make save function always return false
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(flash[:success]).to eq('The institution was successfully updated.')
expect(response).to redirect_to("/institution/list")
end
end
context 'when institution is not updated successfully' do
it 'renders institution#edit' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
allow(institution).to receive(:update_attribute).with(any_args).and_return(false)
put :update, @params
expect(response).to render_template(:edit)
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1
}
# mock a situation that delete action successfully
allow(institution).to receive(:destroy).with(any_args).and_return(true)
post :delete, @params
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://www.youtube.com/watch?v=OZaaVLBul6Y&list=PLaoBe-cpzKA6Eq9xSogYiatOcOeSoRLQN&index=1 click here]

Demo of institution_controller_spec [https://www.youtube.com/watch?v=A1vuITGSRBI&list=PLaoBe-cpzKA6Eq9xSogYiatOcOeSoRLQN&index=2 click here]

== Our Team ==
*Yu-Hsuan Lo (ylo) (githubID: yhslo)

*Chao-Ting Hung (chung4) (githubID: gggho0806)

*Lee Shyu (lshyu) (githubID: ls-hyu)

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T19:00:05Z

Lshyu: /* Demo */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'test institution'

==== Role 1: Admin ====
:admin
*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

==== Role 2: Instructor ====
:instructor, id: 6
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
#Delete an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: TA ====
:teaching_assistant, id: 8
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====
:student
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end
end
context 'when current user is the students' do
it 'deny certain action' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
stub_current_user(instructor, instructor.role.name, instructor.role)
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(flash.now[:success]).to eq('The institution was successfully created.')
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page and returns an error message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
# make save function always return false
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(flash[:success]).to eq('The institution was successfully updated.')
expect(response).to redirect_to("/institution/list")
end
end
context 'when institution is not updated successfully' do
it 'renders institution#edit' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
allow(institution).to receive(:update_attribute).with(any_args).and_return(false)
put :update, @params
expect(response).to render_template(:edit)
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1
}
# mock a situation that delete action successfully
allow(institution).to receive(:destroy).with(any_args).and_return(true)
post :delete, @params
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://www.youtube.com/watch?v=OZaaVLBul6Y&list=PLaoBe-cpzKA6Eq9xSogYiatOcOeSoRLQN&index=1 click here]

Demo of institution_controller_spec [https://www.youtube.com/watch?v=A1vuITGSRBI&list=PLaoBe-cpzKA6Eq9xSogYiatOcOeSoRLQN&index=2 click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T18:50:42Z

Lshyu: /* Code Snippet */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'test institution'

==== Role 1: Admin ====
:admin
*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

==== Role 2: Instructor ====
:instructor, id: 6
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
#Delete an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: TA ====
:teaching_assistant, id: 8
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====
:student
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end
end
context 'when current user is the students' do
it 'deny certain action' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
stub_current_user(instructor, instructor.role.name, instructor.role)
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(flash.now[:success]).to eq('The institution was successfully created.')
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page and returns an error message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
# make save function always return false
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list and returns a successful message' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(flash[:success]).to eq('The institution was successfully updated.')
expect(response).to redirect_to("/institution/list")
end
end
context 'when institution is not updated successfully' do
it 'renders institution#edit' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1,
institution: {
name: "test institution"
}
}
allow(institution).to receive(:update_attribute).with(any_args).and_return(false)
put :update, @params
expect(response).to render_template(:edit)
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
stub_current_user(instructor, instructor.role.name, instructor.role)
@params = {
id:1
}
# mock a situation that delete action successfully
allow(institution).to receive(:destroy).with(any_args).and_return(true)
post :delete, @params
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://youtu.be/OZaaVLBul6Y click here]

Demo of institution_controller_spec [https://youtu.be/A1vuITGSRBI click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T03:06:26Z

Lshyu: /* Institution_controller */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'test institution'

==== Role 1: Admin ====
:admin
*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

==== Role 2: Instructor ====
:instructor, id: 6
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
#Delete an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: TA ====
:teaching_assistant, id: 8
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====
:student
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

let(:course) do
build(:course, instructor_id: 6, institutions_id:1, name: 'abc')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
allow(Course).to receive(:where).with(institution_id: '1').and_return(course)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is super admin or admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action if current user is the TA' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end

it 'deny certain action if current user is the student' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page' do
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page' do
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list' do
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(response).to redirect_to("/institution/list")
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
@params = {
id:1
}
post :delete, @params, session
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://youtu.be/OZaaVLBul6Y click here]

Demo of institution_controller_spec [https://youtu.be/A1vuITGSRBI click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T03:03:23Z

Lshyu: /* Institution_controller */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'institution'

==== Role 1: Admin ====

*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

==== Role 2: Instructor ====
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
#Delete an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: TA ====
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====

Tested tasks that are not allowed and will return false:
#Edit an institution

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

let(:course) do
build(:course, instructor_id: 6, institutions_id:1, name: 'abc')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
allow(Course).to receive(:where).with(institution_id: '1').and_return(course)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is super admin or admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action if current user is the TA' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end

it 'deny certain action if current user is the student' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page' do
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page' do
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list' do
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(response).to redirect_to("/institution/list")
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
@params = {
id:1
}
post :delete, @params, session
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://youtu.be/OZaaVLBul6Y click here]

Demo of institution_controller_spec [https://youtu.be/A1vuITGSRBI click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T03:02:13Z

Lshyu: /* Role 2: instructor */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'institution'

==== Role 1: admin ====

*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: instructor ====
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
#Delete an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: ta ====
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====

Tested tasks that are not allowed and will return false:
#Edit an institution
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

let(:course) do
build(:course, instructor_id: 6, institutions_id:1, name: 'abc')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
allow(Course).to receive(:where).with(institution_id: '1').and_return(course)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is super admin or admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action if current user is the TA' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end

it 'deny certain action if current user is the student' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page' do
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page' do
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list' do
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(response).to redirect_to("/institution/list")
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
@params = {
id:1
}
post :delete, @params, session
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://youtu.be/OZaaVLBul6Y click here]

Demo of institution_controller_spec [https://youtu.be/A1vuITGSRBI click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T03:01:12Z

Lshyu: /* Role 2: instructor */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'institution'

==== Role 1: admin ====

*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: instructor ====
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
#Update the information of an institution
*Tested tasks that will receive false:
#Fail to save a new institution to the database
#Fail to update the information of an institution

==== Role 3: ta ====
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====

Tested tasks that are not allowed and will return false:
#Edit an institution
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

let(:course) do
build(:course, instructor_id: 6, institutions_id:1, name: 'abc')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
allow(Course).to receive(:where).with(institution_id: '1').and_return(course)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is super admin or admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action if current user is the TA' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end

it 'deny certain action if current user is the student' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page' do
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page' do
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list' do
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(response).to redirect_to("/institution/list")
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
@params = {
id:1
}
post :delete, @params, session
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://youtu.be/OZaaVLBul6Y click here]

Demo of institution_controller_spec [https://youtu.be/A1vuITGSRBI click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T02:55:56Z

Lshyu: /* Role 2: instructor */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'institution'

==== Role 1: admin ====

*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: instructor ====
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message
*Tested tasks that will receive false:
#Fail to save a new institution to the database

==== Role 3: ta ====
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====

Tested tasks that are not allowed and will return false:
#Edit an institution
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

let(:course) do
build(:course, instructor_id: 6, institutions_id:1, name: 'abc')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
allow(Course).to receive(:where).with(institution_id: '1').and_return(course)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is super admin or admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action if current user is the TA' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end

it 'deny certain action if current user is the student' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page' do
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page' do
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list' do
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(response).to redirect_to("/institution/list")
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
@params = {
id:1
}
post :delete, @params, session
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://youtu.be/OZaaVLBul6Y click here]

Demo of institution_controller_spec [https://youtu.be/A1vuITGSRBI click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]

CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin controller.rb and institution controller.rb

2021-10-19T02:54:04Z

Lshyu: /* Role 2: instructor */

== E2134. Write unit tests for admin controller.rb and institution controller.rb ==
This page is a description of Expertiza OSS project E2134. - Write unit tests for admin controller.rb and institution controller.rb

== Problem Statement and Background ==

Expertiza allows authorized users to create/edit/delete information of institutions and for the admin to create/edit/delete information of instructors. The repository lacks systematic unit tests for both the admin controller and institution controller. We designed unit tests for these controllers based on several scenarios.

== Implementation ==

=== Admin_controller ===

==== Role 1: admin1 ====
User type: admin, id: 3, role_id: 4, parent_id: 1, name: 'Aministrator1'
*Tested tasks allowed:
#Lists all the instructors
#:For users like admin or super admin, they are supposed to be able to list all the instructors in the database.
#Remove an instructor
#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: admin2 ====
User type: admin, id: 4, role_id: 4, parent_id: 1, name: 'Aministrator2'

The data of admin 2 is used for super admin to test functions such as list administrators, etc.

==== Role 3: super_admin ====
User type: superadmin, id: 1, role_id: 5

Super admin should be able to perform all the tasks other types of users can do.

==== Role 4: instructor1 ====
User type: instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1'
Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
User type: instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2'

The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
User type: student, id: 21, role_id: 1

Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
#spec/controllers/admin_controller_spec.rb
describe AdminController do
# create fake users
let(:admin1) { build(:admin, id: 3, role_id: 4, parent_id: 1, name: 'Administrator1') }
let(:admin2) { build(:admin, id: 4, role_id: 4, parent_id: 1, name: 'Administrator2') }
let(:super_admin) { build(:superadmin, id: 1, role_id: 5) }
let(:instructor1) { build(:instructor, id: 10, role_id: 3, parent_id: 3, name: 'Instructor1') }
let(:instructor2) { build(:instructor, id: 11, role_id: 3, parent_id: 4, name: 'Instructor2') }
let(:student1) { build(:student, id: 21, role_id: 1) }

# create fake lists
let(:admin_list) { [admin1, admin2] }
let(:instructor_list) { [instructor1, instructor2] }
let(:instructor_list_pid3) { [instructor1] }
let(:instructor_list_pid4) { [instructor2] }

# define default behaviors for each method call
before(:each) do
allow(User).to receive(:find).with('3').and_return(admin1)
allow(User).to receive(:find).with('1').and_return(super_admin)
allow(User).to receive(:find).with('10').and_return(instructor1)
allow(User).to receive(:where).with(["role_id = ?", super_admin.role_id]).and_return([ super_admin ])

allow(User).to receive(:where).with(role_id: admin1.role).and_return(admin_list)
allow(admin_list).to receive(:order).with(:name).and_return(admin_list)
allow(admin_list).to receive(:where).with("parent_id = ?", super_admin.id).and_return(admin_list)
allow(admin_list).to receive(:paginate).with(page: '1', per_page: 50).and_return(admin_list)

allow(User).to receive(:where).with(role_id: instructor1.role).and_return(instructor_list)
allow(instructor_list).to receive(:order).with(:name).and_return(instructor_list)
allow(instructor_list).to receive(:where).with("parent_id = ?", admin1.id).and_return(instructor_list_pid3)
allow(instructor_list_pid3).to receive(:paginate).with(page: '1', per_page: 50).and_return(instructor_list_pid3)
end

describe '#action_allowed?' do
context 'when params action is list all instructors' do
before(:each) do
controller.params = {action: 'list_instructors'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is remove an instructor' do
before(:each) do
controller.params = {action: 'remove_instructor'}
end

context 'when the role of current user is Admin' do
it 'allows certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end

context 'when params action is other than list and remove instructors' do
before(:each) do
controller.params = {:action => 'remove_administrator'}
end

context 'when the role of current user is Admin' do
it 'refuses certain action' do
stub_current_user(admin1, admin1.role.name, admin1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Super-Admin' do
it 'allows certain action' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when the role of current user is Instructor' do
it 'refuses certain action' do
stub_current_user(instructor1, instructor1.role.name, instructor1.role)
(controller.send(:action_allowed?)).should be false
end
end

context 'when the role of current user is Student' do
it 'refuses certain action' do
stub_current_user(student1, student1.role.name, student1.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

context '#list_super_administrators' do
it 'lists all the Super-Administrators' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
get :list_super_administrators
expect(assigns(:users)).to eq([ super_admin ])
end
end

context '#show_super_administrator' do
it 'find selected Super-Administrator and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '1'}
get :show_super_administrator, params
expect(assigns(:user)).to eq(super_admin)
expect(assigns(:role)).to eq(super_admin.role)
expect(response).to render_template(:show_super_administrator)
end
end

context '#list_administrators' do
it 'lists all the admins' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {page: '1'}
get :list_administrators, params
expect(assigns(:users)).to eq(admin_list)
end
end

context '#show_administrator' do
it 'find selected admin and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '3'}
get :show_administrator, params
expect(assigns(:user)).to eq(admin1)
expect(assigns(:role)).to eq(admin1.role)
expect(response).to render_template(:show_administrator)
end
end

context '#list_instructors' do
it 'lists all the instructors' do
stub_current_user(admin1, admin1.role.name, admin1.role)
params = {page: '1'}
get :list_instructors, params
expect(assigns(:users)).to eq(instructor_list_pid3)
end
end

context '#show_instructor' do
it 'find selected instructor and render #show' do
stub_current_user(super_admin, super_admin.role.name, super_admin.role)
params = {id: '10'}
get :show_instructor, params
expect(assigns(:user)).to eq(instructor1)
expect(assigns(:role)).to eq(instructor1.role)
expect(response).to render_template(:show_instructor)
end
end
end
</pre>

=== Institution_controller ===
:institution, id: 1, name: 'institution'

==== Role 1: admin ====

*Tested tasks allowed:
#Edit an institution
#:For users like admin, they are supposed to be able to edit all the institutions in the database.

#:For users like admin or super admin, they are supposed to be able to remove an instructor from the database.
*Tested tasks that are not allowed:
#Remove an administrator
#:For users like admin, they are not supposed to be able to delete his/her own user account or any other administrators.

==== Role 2: instructor ====
*Tested tasks allowed:
#Edit an institution
#Creates a new institution object and renders institution new page
#Save a new institution to the database and being redirected to the institution list page with a successful message

==== Role 3: ta ====
Tested tasks that are not allowed and will return false:
#Edit an institution

==== Role 4: student ====

Tested tasks that are not allowed and will return false:
#Edit an institution
#Remove an instructor
#Remove administrator

==== Role 5: instructor2 ====
The data of instructor 2 is used to test functions such as list instructors, etc.

==== Role 6: student1 ====
Student should not be able to perform any tasks within the admin controller.

Tested tasks that are not allowed and will return false:
#List all instructors
#Remove an instructor
#Remove an administrator

==== Code Snippet ====
<pre>
require 'rails_helper'
describe InstitutionController do
let(:admin) { build(:admin) }
let(:instructor) { build(:instructor, id: 6) }
let(:instructor2) { build(:instructor, id: 66) }
let(:ta) { build(:teaching_assistant, id: 8) }
let(:student) { build(:student) }

# create fake data
let(:institution) do
build(:institution, id: 1, name: 'test institution')
end

let(:course) do
build(:course, instructor_id: 6, institutions_id:1, name: 'abc')
end

# set default testing user
before(:each) do
allow(Institution).to receive(:find).with('1').and_return(institution)
allow(Course).to receive(:where).with(institution_id: '1').and_return(course)
stub_current_user(instructor, instructor.role.name, instructor.role)
end
describe '#action_allowed?' do

context 'when params action is edit or update' do
before(:each) do
controller.params = {id: '1', action: 'edit'}
end

context 'when the role name of current user is super admin or admin' do
it 'allows certain action' do
stub_current_user(admin, admin.role.name, admin.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the instructor' do
it 'allows certain action' do
stub_current_user(instructor, instructor.role.name, instructor.role)
(controller.send(:action_allowed?)).should be true
end
end

context 'when current user is the TAs or the students' do
it 'deny certain action if current user is the TA' do
stub_current_user(ta, ta.role.name, ta.role)
(controller.send(:action_allowed?)).should be false
end

it 'deny certain action if current user is the student' do
stub_current_user(student, student.role.name, student.role)
(controller.send(:action_allowed?)).should be false
end
end
end
end

describe '#new' do
it 'creates a new Institution object and renders institution#new page' do
get :new
expect(response).to render_template(:new)
end
end

describe '#create' do
context 'when institution is saved successfully' do
it 'redirects to institution#list page' do
allow(institution).to receive(:name).and_return("test institution")
@params = {
institution: {
name: "test institution"
}
}
post :create, @params
expect(response).to redirect_to("/institution/list")
end
end

context 'when institution is not saved successfully' do
it 'renders institution#new page' do
allow(institution).to receive(:save).and_return(false)
@params = {
institution: {
name: ""
}
}
post :create, @params
expect(flash.now[:error]).to eq('The creation of the institution failed.')
expect(response).to render_template(:new)
end
end
end
describe '#edit' do
it 'renders institution#edit' do
@params = {
id: 1
}
get :edit, @params
expect(response).to render_template(:edit)
end
end

describe '#update' do
context 'when institution is updated successfully' do
it 'renders institution#list' do
@params = {
id:1,
institution: {
name: "test institution"
}
}
put :update, @params
expect(response).to redirect_to("/institution/list")
end
end
end

describe '#index' do
context 'when institution query all institution' do
it 'renders institution#list' do
get :index
expect(response).to render_template(:list)
end
end
end

describe '#show' do
context 'when try to show a institution' do
it 'renders institution#show when find the target institution' do
@params = {
id:1
}
get :show, @params
expect(response).to render_template(:show)
end
end
end

describe '#delete' do
context 'when try to delete a institution' do
it 'renders institution#list when delete successfully' do
@params = {
id:1
}
post :delete, @params, session
expect(response).to redirect_to("/institution/list")
end
end
end
end
</pre>

== Demo ==

Demo of admin_controller_spec [https://youtu.be/OZaaVLBul6Y click here]

Demo of institution_controller_spec [https://youtu.be/A1vuITGSRBI click here]

== Our Team ==

== References ==

Expertiza on GitHub [https://github.com/expertiza/expertiza click here]

To visit our forked repo [https://github.com/yhslo/expertiza click here]

View our pull request [https://github.com/expertiza/expertiza click here]