Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-24T23:30:25Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

===1) Moving Find Resource Out of Controller===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

===2) Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb ===
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

===3) Renamed and improved method names ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

===4) Implement self.assessment in Review Response Map ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

===5) Moved Score Calculation from ResponseMap to ResponseObject===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

===6) Added Skippable Question Logic to Quizzes===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

===7) Refactored Parameters===

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

===Migration files===

* Added skippable to facilitate the skippable function to item table
* Changed the column_name to item in quiz_choices as the current table name is item, not questions.

== Implementation Details ==

===1) Refactoring and Moving Business Logic===

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

===2) Error Fixes===

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

===3) RSpec Testing===

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:50:49Z

Kjoshi4: /* 3) RSpec Testing */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

===1) Moving Find Resource Out of Controller===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

===2) Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb ===
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

===3) Renamed and improved method names ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

===4) Implement self.assessment in Review Response Map ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

===5) Moved Score Calculation from ResponseMap to ResponseObject===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

===6) Added Skippable Question Logic to Quizzes===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

===7) Refactored Parameters===

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

== Implementation Details ==

===1) Refactoring and Moving Business Logic===

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

===2) Error Fixes===

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

===3) RSpec Testing===

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:50:38Z

Kjoshi4: /* 2) Error Fixes */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

===1) Moving Find Resource Out of Controller===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

===2) Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb ===
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

===3) Renamed and improved method names ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

===4) Implement self.assessment in Review Response Map ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

===5) Moved Score Calculation from ResponseMap to ResponseObject===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

===6) Added Skippable Question Logic to Quizzes===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

===7) Refactored Parameters===

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

== Implementation Details ==

===1) Refactoring and Moving Business Logic===

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

===2) Error Fixes===

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

==='''3) RSpec Testing'''===

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:50:22Z

Kjoshi4: /* 1) Refactoring and Moving Business Logic */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

===1) Moving Find Resource Out of Controller===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

===2) Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb ===
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

===3) Renamed and improved method names ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

===4) Implement self.assessment in Review Response Map ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

===5) Moved Score Calculation from ResponseMap to ResponseObject===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

===6) Added Skippable Question Logic to Quizzes===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

===7) Refactored Parameters===

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

== Implementation Details ==

===1) Refactoring and Moving Business Logic===

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

==='''2) Error Fixes'''===

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

==='''3) RSpec Testing'''===

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:49:56Z

Kjoshi4: /* Implementation Details */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

===1) Moving Find Resource Out of Controller===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

===2) Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb ===
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

===3) Renamed and improved method names ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

===4) Implement self.assessment in Review Response Map ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

===5) Moved Score Calculation from ResponseMap to ResponseObject===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

===6) Added Skippable Question Logic to Quizzes===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

===7) Refactored Parameters===

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

== Implementation Details ==

==='''1) Refactoring and Moving Business Logic'''===

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

==='''2) Error Fixes'''===

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

==='''3) RSpec Testing'''===

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:49:08Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

===1) Moving Find Resource Out of Controller===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

===2) Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb ===
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

===3) Renamed and improved method names ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

===4) Implement self.assessment in Review Response Map ===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

===5) Moved Score Calculation from ResponseMap to ResponseObject===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

===6) Added Skippable Question Logic to Quizzes===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

===7) Refactored Parameters===

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

== Implementation Details ==

'''1) Refactoring and Moving Business Logic'''

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

'''2) Error Fixes'''

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

'''3) RSpec Testing'''

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:47:45Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

===<b>1) Moving Find Resource Out of Controller</b>===

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

<b>7) Refactored Parameters</b>

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

== Implementation Details ==

'''1) Refactoring and Moving Business Logic'''

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

'''2) Error Fixes'''

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

'''3) RSpec Testing'''

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:47:08Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

<b>7) Refactored Parameters</b>

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

== Implementation Details ==

'''1) Refactoring and Moving Business Logic'''

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

'''2) Error Fixes'''

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

'''3) RSpec Testing'''

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T18:46:36Z

Kjoshi4: /* Implementation Details */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

<b>7) Refactored Parameters</b>

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

== Implementation Details ==

'''1) Refactoring and Moving Business Logic'''

The following changes were made to improve maintainability and follow MVC principles:

* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the create_score method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7 Refactored the process_answers method]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c Moved findResource logic to a separate file]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398 Implemented self.assessments_for in ReviewResponseMap]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869 Renamed methods in student_quizzes_controller.rb for clarity]

'''2) Error Fixes'''

* [https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166 Fixed ResponseMap error]
* [https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49 Resolved assignment dependency issue]

'''3) RSpec Testing'''

* [https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb Added request specs for student_quizzes_controller]

RSpec tests were written for all major controller actions, model logic (including skippable question scoring), and error handling paths. This ensures the correctness of the refactored implementation and guards against regressions.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel32@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T02:03:28Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

<b>7) Refactored Parameters</b>

'''Before:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:assignment_id,
:questionnaire_type,
:private,
questions_attributes: [
:id,
:txt,
:question_type,
:break_before,
:correct_answer,
:score_value,
{ answers_attributes: %i[id answer_text correct] }
]
)
end
</syntaxhighlight>

'''After:'''
<syntaxhighlight lang="ruby">
def questionnaire_params
params.require(:questionnaire).permit(
:name,
:instructor_id,
:min_question_score,
:max_question_score,
:questionnaire_type,
:private,
items_attributes: [
:txt,
:question_type,
:break_before,
:weight,
:skippable,
:seq,
{ quiz_question_choices_attributes: %i[txt iscorrect] }
]
)
end
</syntaxhighlight>

This change improves compatibility with the updated data model and supports dynamic quiz item rendering, skippable questions, and proper nesting for answer choices.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T01:59:03Z

Kjoshi4: /* Video */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://youtu.be/T_qFnMeGhyg

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-23T01:58:46Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
</div>
<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz_15.jpeg|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

d) Renaming create_questions_and_answers to create_items_and_choices: There were discrepancies in the database. The question model was renamed to item and there were choices associated with it. The new name is more meaningful.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/blob/b0079c802e46f4a7e22c1c4ea1757be51ebda23b/spec/requests/api/v1/student_quizzes_controller_spec.rb) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
We added three test cases in the file: <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored methods in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

After adding the tests, our test overage increased by 6% from 68% to around 74%.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure the robustness of the refactored controller and the correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

https://drive.google.com/file/d/14sq5o2o3nLxn9rcJlVfXYfeQOg0EXlly/view?usp=sharing

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

File:Student quiz 15.jpeg

2025-04-23T01:52:32Z

Kjoshi4:

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T20:19:53Z

Kjoshi4:

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored method in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

----

Below is a comprehensive test matrix for each component and method.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Create sample quiz.<br>GET request.<br>Expect 200 OK & array response.
|-
| create (skippable) || POST || /api/v1/student_quizzes || #create || Create quiz with skippable items || POST with `skippable: true`.<br>Expect 201 Created.
|-
| create (non-skippable) || POST || /api/v1/student_quizzes || #create || Create quiz with non-skippable items || POST with `skippable: false`.<br>Expect 201 Created.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Create quiz.<br>DELETE request.<br>Expect 204 No Content.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz || Fetch by ID.<br>Expect 200 OK.
|-
| assign_quiz || POST || /student_quizzes/assign || #assign_quiz || Assign to participant || POST assignment.<br>Expect 201 Created.
|-
| submit_quiz || POST || /submit_answers || #submit_quiz || Submit answers || POST quiz answers.<br>Expect 200 OK + score in response.
|-
| update || PUT || /student_quizzes/:id || #update || Update quiz || PUT updated name.<br>Expect 200 OK.
|-
| fetch_quiz || GET || /student_quizzes/:id || #fetch_quiz || Fetch quiz || Validate correct fetch using new method.
|-
| render_success || GET || /student_quizzes || #render_success || Render success || Expect 200 OK.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Permit strong parameters || Handles nested attributes + validation.
|-
| create_questions_and_answers || N/A || create_questions_and_answers || #create_questions_and_answers || Create nested resources || Save questions/answers with `quiz_question_choices_attributes`.
|-
| render_error || N/A || render_error || #render_error || Custom error responses || 422 + error message check.
|-
| quiz_assigned? || N/A || quiz_assigned? || #quiz_assigned? || Check assignment || Return true/false.
|-
| build_response_map || N/A || build_response_map || #build_response_map || Link quiz + participant || Valid object or nil return.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Auth role check.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Score responses || Mock score.<br>Expect correct total.
|-
| find_or_initialize_response || find_or_initialize_response || #find_or_initialize_response || Load/init response || Existing or new response returned.
|-
| get_score || get_score || #get_score || Fetch quiz score || Return score or nil.
|-
| process_answers || process_answers || #process_answers || Grade answers || Mock pass/fail.<br>Return boolean.
|-
| build_response_map || build_response_map || #build_response_map || Return valid map || Valid object or nil.
|-
| find_for_current_user || find_for_current_user || #find_for_current_user || Locate user’s response || Return matching map.
|}

==== Tests for <code>response_spec.rb</code> ====

This model now handles the core quiz scoring logic and validation.

{| class="wikitable"
! Method !! Description !! Key Scenarios Tested
|-
| reportable_difference? || Detect score deviation across responses || False when only one response.<br>True if deviation > notification limit.
|-
| calculate_total_score || Compute total score using weighted scorable items || Correct score returned when answers match and skippable items are ignored.
|-
| average_score || Calculate % based on total/max || 0 when max score = 0.<br>80 when total = 4 and max = 5.
|-
| maximum_score || Total max possible based on weights || 0 if all items are skipped.<br>Correct total otherwise.
|-
| response_assignment || Fetch assignment from ResponseMap or ReviewResponseMap || Proper assignment returned from either Participant or Reviewee link.
|}

<syntaxhighlight lang="ruby">
describe '#maximum_score' do
it 'ignores skippable items from max score' do
item_skipped = ScoredItem.new(weight: 2, skippable: true)
questionnaire.items = [item_skipped]
allow(questionnaire).to receive(:max_question_score).and_return(5)
allow(response).to receive(:questionnaire_by_answer).and_return(questionnaire)
response.scores = []
expect(response.maximum_score).to eq(0)
end
end
</syntaxhighlight>

==== Additional Spec Files ====

- <code>find_resource_service_spec.rb</code>: Validates correctness of resource fetching and exception handling for missing models.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure robustness of the refactored controller, and correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Video==

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T20:19:16Z

Kjoshi4: /* Testing */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored method in `StudentQuizzesController` and associated models.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.
'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

----

Below is a comprehensive test matrix for each component and method.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Create sample quiz.<br>GET request.<br>Expect 200 OK & array response.
|-
| create (skippable) || POST || /api/v1/student_quizzes || #create || Create quiz with skippable items || POST with `skippable: true`.<br>Expect 201 Created.
|-
| create (non-skippable) || POST || /api/v1/student_quizzes || #create || Create quiz with non-skippable items || POST with `skippable: false`.<br>Expect 201 Created.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Create quiz.<br>DELETE request.<br>Expect 204 No Content.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz || Fetch by ID.<br>Expect 200 OK.
|-
| assign_quiz || POST || /student_quizzes/assign || #assign_quiz || Assign to participant || POST assignment.<br>Expect 201 Created.
|-
| submit_quiz || POST || /submit_answers || #submit_quiz || Submit answers || POST quiz answers.<br>Expect 200 OK + score in response.
|-
| update || PUT || /student_quizzes/:id || #update || Update quiz || PUT updated name.<br>Expect 200 OK.
|-
| fetch_quiz || GET || /student_quizzes/:id || #fetch_quiz || Fetch quiz || Validate correct fetch using new method.
|-
| render_success || GET || /student_quizzes || #render_success || Render success || Expect 200 OK.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Permit strong parameters || Handles nested attributes + validation.
|-
| create_questions_and_answers || N/A || create_questions_and_answers || #create_questions_and_answers || Create nested resources || Save questions/answers with `quiz_question_choices_attributes`.
|-
| render_error || N/A || render_error || #render_error || Custom error responses || 422 + error message check.
|-
| quiz_assigned? || N/A || quiz_assigned? || #quiz_assigned? || Check assignment || Return true/false.
|-
| build_response_map || N/A || build_response_map || #build_response_map || Link quiz + participant || Valid object or nil return.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Auth role check.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Score responses || Mock score.<br>Expect correct total.
|-
| find_or_initialize_response || find_or_initialize_response || #find_or_initialize_response || Load/init response || Existing or new response returned.
|-
| get_score || get_score || #get_score || Fetch quiz score || Return score or nil.
|-
| process_answers || process_answers || #process_answers || Grade answers || Mock pass/fail.<br>Return boolean.
|-
| build_response_map || build_response_map || #build_response_map || Return valid map || Valid object or nil.
|-
| find_for_current_user || find_for_current_user || #find_for_current_user || Locate user’s response || Return matching map.
|}

==== Tests for <code>response_spec.rb</code> ====

This model now handles the core quiz scoring logic and validation.

{| class="wikitable"
! Method !! Description !! Key Scenarios Tested
|-
| reportable_difference? || Detect score deviation across responses || False when only one response.<br>True if deviation > notification limit.
|-
| calculate_total_score || Compute total score using weighted scorable items || Correct score returned when answers match and skippable items are ignored.
|-
| average_score || Calculate % based on total/max || 0 when max score = 0.<br>80 when total = 4 and max = 5.
|-
| maximum_score || Total max possible based on weights || 0 if all items are skipped.<br>Correct total otherwise.
|-
| response_assignment || Fetch assignment from ResponseMap or ReviewResponseMap || Proper assignment returned from either Participant or Reviewee link.
|}

<syntaxhighlight lang="ruby">
describe '#maximum_score' do
it 'ignores skippable items from max score' do
item_skipped = ScoredItem.new(weight: 2, skippable: true)
questionnaire.items = [item_skipped]
allow(questionnaire).to receive(:max_question_score).and_return(5)
allow(response).to receive(:questionnaire_by_answer).and_return(questionnaire)
response.scores = []
expect(response.maximum_score).to eq(0)
end
end
</syntaxhighlight>

==== Additional Spec Files ====

- <code>find_resource_service_spec.rb</code>: Validates correctness of resource fetching and exception handling for missing models.

----

'''Conclusion''':
The RSpec suite thoroughly validates controller functionality, model-level scoring, and key edge cases like skippable questions and zero scoring boundaries. These tests ensure robustness of the refactored controller, and correctness of all new features introduced.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:54:40Z

Kjoshi4: /* Testing */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===

After setting up authentication and creating test users and roles, we implemented request-level and unit-level RSpec tests to validate the functionality of each action and refactored method in `StudentQuizzesController`.

Below is an example of testing the <code>#index</code> action:

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(
name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10
)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

In addition to the above, we tested quiz creation with both skippable and non-skippable items:

<syntaxhighlight lang="ruby">
describe '#create' do
it 'creates a questionnaire with skippable items and choices' do
post api_v1_student_quizzes_path,
params: skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end

it 'creates a questionnaire with non-skippable items and choices' do
post api_v1_student_quizzes_path,
params: non_skipable_valid_attrs.to_json,
headers: auth_headers

expect(response).to have_http_status(:created)
end
end
</syntaxhighlight>

We also tested quiz update functionality:

<syntaxhighlight lang="ruby">
describe '#update' do
it 'updates a questionnaire' do
put "/api/v1/student_quizzes/#{quiz.id}",
params: { questionnaire: { name: 'Updated Questionnaire' } }.to_json,
headers: auth_headers

expect(response).to have_http_status(:ok)
expect(JSON.parse(response.body)['name']).to eq('Updated Questionnaire')
end
end
</syntaxhighlight>

----

Below is a comprehensive test matrix for each component and method.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Create sample quiz.<br>GET request.<br>Expect 200 OK & array response.
|-
| create (skippable) || POST || /api/v1/student_quizzes || #create || Create quiz with skippable items || POST with `skippable: true`.<br>Expect 201 Created.
|-
| create (non-skippable) || POST || /api/v1/student_quizzes || #create || Create quiz with non-skippable items || POST with `skippable: false`.<br>Expect 201 Created.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Create quiz.<br>DELETE request.<br>Expect 204 No Content.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz || Fetch by ID.<br>Expect 200 OK.
|-
| assign_quiz || POST || /student_quizzes/assign || #assign_quiz || Assign to participant || POST assignment.<br>Expect 201 Created.
|-
| submit_quiz || POST || /submit_answers || #submit_quiz || Submit answers || POST quiz answers.<br>Expect 200 OK + score in response.
|-
| update || PUT || /student_quizzes/:id || #update || Update quiz || PUT updated name.<br>Expect 200 OK.
|-
| fetch_quiz || GET || /student_quizzes/:id || #fetch_quiz || Fetch quiz || Validate correct fetch using new method.
|-
| render_success || GET || /student_quizzes || #render_success || Render success || Expect 200 OK.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Permit strong parameters || Handles nested attributes + validation.
|-
| create_questions_and_answers || N/A || create_questions_and_answers || #create_questions_and_answers || Create nested resources || Save questions/answers with `quiz_question_choices_attributes`.
|-
| render_error || N/A || render_error || #render_error || Custom error responses || 422 + error message check.
|-
| quiz_assigned? || N/A || quiz_assigned? || #quiz_assigned? || Check assignment || Return true/false.
|-
| build_response_map || N/A || build_response_map || #build_response_map || Link quiz + participant || Valid object or nil return.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Auth role check.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Score responses || Mock score.<br>Expect correct total.
|-
| find_or_initialize_response || find_or_initialize_response || #find_or_initialize_response || Load/init response || Existing or new response returned.
|-
| get_score || get_score || #get_score || Fetch quiz score || Return score or nil.
|-
| process_answers || process_answers || #process_answers || Grade answers || Mock pass/fail.<br>Return boolean.
|-
| build_response_map || build_response_map || #build_response_map || Return valid map || Valid object or nil.
|-
| find_for_current_user || find_for_current_user || #find_for_current_user || Locate user’s response || Return matching map.
|}

==== Additional Spec Files ====
- <code>find_resource_service_spec.rb</code>: Validates correctness of resource fetching logic and custom error handling for missing records.

----

'''Conclusion''': The test suite comprehensively validates controller behavior, model logic, and edge cases (like quiz skipping, parameter whitelisting, and deletion). All test cases passed successfully, ensuring stable reimplementation.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:45:33Z

Kjoshi4: /* Next Steps */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:43:41Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:43:11Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes<b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

Skippable quiz questions are now supported with a `skippable` attribute added to quiz items. The system will now skip over these questions during answer validation and scoring, improving flexibility for quiz creators. Logic to process `skippable` answers was added during submission.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:39:43Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b>6) Added Skippable Question Logic to Quizzes<b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:39:13Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b> Added Skippable Question Logic to Quizzes<b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

File:Student quiz 13.jpeg

2025-04-22T19:38:17Z

Kjoshi4:

File:Student quiz 13.png

2025-04-22T19:31:55Z

Kjoshi4:

File:Student quiz 14.jpeg

2025-04-22T19:31:07Z

Kjoshi4:

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:30:38Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

<b> Added Skippable Question Logic to Quizzes<b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''db/migrate/20250421052650_add_skippable_to_items.rb'''
[[File:student_quiz_13.png|400px]]
</div>
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz_14.jpeg|650px]]
</div>
</div>

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:25:17Z

Kjoshi4:

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b><b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.jpeg|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.jpeg|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

File:Student quiz 12.jpeg

2025-04-22T19:22:37Z

Kjoshi4:

File:Student quiz 11.jpeg

2025-04-22T19:21:31Z

Kjoshi4:

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:17:57Z

Kjoshi4: /* Changes Implemented */

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

<b><b>5) Moved Score Calculation from ResponseMap to ResponseObject</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/response.rb'''
[[File:student_quiz_11.png|400px]]
</div>
<div style="text-align:center;">
'''app/models/response_map.rb'''
[[File:student_quiz_12.png|650px]]
</div>
</div>

The method to calculate quiz scores was previously placed in `ResponseMap`, which violates SRP and tightly couples quiz logic to mapping logic. This has now been moved to the `Response` model, which represents student answers and is the appropriate layer to handle score calculation. This also improves future support for multiple quiz attempts and better aligns with the system's domain model.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-22T19:01:00Z

Kjoshi4:

==Introduction==
[https://expertiza.ncsu.edu/ Expertiza] is an educational web application collaboratively developed and maintained by students and faculty at NCSU. As an open-source project built on the Ruby on Rails platform, its code is accessible on GitHub. The platform enables students to provide peer reviews and refine their work based on feedback.

==Project Overview==
Quizzes in Expertiza are designed to ensure that reviewers comprehend the material they are evaluating. When an assignment includes quizzes, submitting teams create these quizzes based on their work. Reviewers must complete the quizzes before reviewing to demonstrate their understanding. If a reviewer performs poorly, their review can be discounted to maintain quality.

The student_quizzes_controller.rb manages quiz-related actions, including quiz creation, scoring, and recording responses for both students and reviewers. However, the existing implementation violates several key Rails principles, including the DRY (Don't Repeat Yourself) principle and the improper placement of business logic within the controller. Instead, this logic should reside in model classes, in adherence to the MVC (Model-View-Controller) architecture.

==Previous Implementation==
The previous implementation of the student_quizzes_controller.rb contained several design issues. While some progress was made, such as moving calculate_score and process_answers to the ResponseMap model and replacing role ID checks with Role model methods, several key issues remained.
Business logic was still embedded in the controller, violating the Single Responsibility Principle (SRP). Method names were unclear, like set_student_quiz, and resource-finding logic was incorrectly placed in the controller. Additionally, quiz retake policies and question-skipping lacked adequate support. Testing coverage was also insufficient, and documentation needed improvement. Fixing these issues will significantly enhance the code's maintainability, clarity, and overall structure.

==Project Goals==
This project focuses on reimplementing student_quizzes_controller.rb in the reimplementation-backend repository, addressing issues from the previous implementation. Key improvements will include:

* Improving method names and readability to better align with their purposes
* Refactoring to remove redundant code and consolidate functionality into reusable functions
* Enhancing test coverage and documentation clarity

By addressing these issues, the project aims to produce a well-structured, maintainable, and scalable student_quizzes_controller.rb that follows Rails best practices, improves code organization, and enhances the overall maintainability of the Expertiza platform.

==Design==

===Key Features===
<b>1) Controller Actions:</b> The StudentQuizzesController is responsible for managing quiz-related functionalities such as creating quizzes, assigning quizzes to students, submitting answers, updating quizzes, and deleting quizzes. Below is an overview of the main actions and their responsibilities:
* Index <code>(GET /student_quizzes)</code>: Retrieves all available quizzes (questionnaires) from the database.
* Show <code>(GET /student_quizzes/:id)</code>: Fetches a single quiz (questionnaire) by its ID.
* Create <code>(POST /student_quizzes)</code>: Creates a new quiz along with its associated questions and answers.
* Assign Quiz <code>(POST /student_quizzes/assign)</code>: Assigns a specific quiz to a student.
* Submit Quiz <code>(POST /student_quizzes/submit_answers)</code>: Allows the student to submit answers for a quiz and calculates the total score.
* Update <code>(PUT /student_quizzes/:id)</code>: Updates an existing quiz.
* Destroy <code>(DELETE /student_quizzes/:id)</code>: Deletes a specific quiz.

<b>2) Services and Helpers:</b> Several helper methods and service objects are used to encapsulate complex logic and improve code readability.
* FindResourceService: This service is responsible for fetching resources (e.g., <code>Participant</code>, <code>Questionnaire</code>) from the database. It helps keep the controller code clean and focused on the action logic.
* ResponseMap: This class is used to map students to quizzes and track their responses. The controller checks if a student is already assigned to a quiz before creating a new assignment. It also handles the processing of answers and the calculation of total scores.

<b>3) Role-Based Access Control:</b> The <code>before_action</code>callback <code>check_instructor_role</code> ensures that only users with an instructor role (role_id = 2) can perform certain actions, such as assigning quizzes and creating new ones. This ensures that only authorized users can access sensitive functionalities.

<b>4) Error Handling:</b> The controller uses standard error handling to ensure the system responds gracefully in case of any issues. If an error occurs (e.g., quiz already assigned, invalid data), a custom error message is rendered along with the appropriate HTTP status code.
For example, when a quiz is assigned to a student, if the student is already assigned, the system returns a unprocessable_entity error with a descriptive message.

<b>5) Transaction Handling:</b> The <code>create</code> and <code>submit_quiz</code> actions use database transactions (ActiveRecord::Base.transaction) to ensure that operations are atomic. If any part of the process fails (e.g., saving answers), the entire transaction is rolled back to maintain data integrity.

===UML Diagram===
[[File:student_quizzes_UML.png|650px]]

===Sequence of Actions in Assigning a Quiz===

1) The instructor calls the <code>POST /student_quizzes/assign</code> endpoint to assign a quiz.<br>
2) The <code>assign_quiz</code> method is invoked:<br>
* FindParticipant: The <code>FindResourceService</code> is called to retrieve the Participant and Questionnaire by their respective IDs.
* Check Assignment: The <code>quiz_assigned?</code> method checks whether the quiz has already been assigned to the student.
* Build ResponseMap: A new <code>ResponseMap</code> is created, linking the student to the quiz.
* Save ResponseMap: The <code>ResponseMap</code> is saved to the database, completing the assignment process.
* The system responds with the newly created ResponseMap and a success message.

===Sequence of Actions in Submitting Quiz Answers===
1) The student submits their answers to the quiz via the <code>POST /student_quizzes/submit_answers</code> endpoint.<br>
2) The <code>submit_quiz</code> method is invoked:<br>
* Find ResponseMap: The system retrieves the <code>ResponseMap</code> for the current user and quiz.
* Process Answers: The student's answers are processed and associated with the <code>ResponseMap</code>.
* Calculate Score: The <code>calculate_score</code> method is called to compute the total score based on the answers provided.
* Update ResponseMap: The <code>ResponseMap</code> is updated with the total score.
* The system responds with the calculated score.

==Files Modified==

* app/models/response_map.rb
* app/controllers/api/v1/student_quizzes_controller.rb
* app/services/find_resource_service.rb
* app/models/response.rb
* spec/requests/api/v1/student_quizzes_controller_spec.rb
* spec/services/resource_map_spec.rb

==Changes Implemented==

<b>1) Moving Find Resource Out of Controller</b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/controllers/api/v1/student_quizzes_controller.rb'''
[[File:student_quiz1.png|400px]]
</div>
<div style="text-align:center;">
'''app/services/find_resource_service.rb'''
[[File:student_quiz2.png|650px]]
</div>
</div>

The method renaming and extraction of logic to a service are intended to improve the maintainability, readability, and scalability of the code. The refactor helps ensure that the controller remains focused on its core responsibility of handling HTTP requests while delegating resource lookup to the service. The FindResourceService improves error handling by ensuring that any ActiveRecord::RecordNotFound exceptions are caught and a custom message is raised, enhancing the user experience.

<b>
2)
Ensured deleting a quiz is handled correctly in student_quizzes_controller.rb </b>
<div>
<div style="text-align:center;">
[[File:student_quiz3.png|600px]]
</div>
</div>'

This change ensures that the destroy action in the student_quizzes_controller.rb behaves correctly in all cases, including when attempting to delete a non-existent quiz.

<b>3) Renamed and improved method names </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">

[[File:student_quiz4.png|300px]]
</div>

<div style="text-align:center;">
[[File:student_quiz5.png|300px]]
</div>
<div style="text-align:center;">
[[File:student_quiz7.png|300px]]
</div>
</div>

a) Renaming assign_quiz_to_student to assign_quiz: The refactored name, assign_quiz, is simpler and still clear in the context of assigning a quiz. It follows the principle of keeping method names concise without losing meaning, making the code easier to maintain and read.

b) Renaming quiz_already_assigned? to quiz_assigned?: The renaming simplifies the method name while keeping its meaning intact. The method still performs the same check, but the new name improves code clarity and readability.

c) Renaming set_student_quiz to fetch_quiz: The new name, fetch_quiz, is more descriptive and aligns better with the method's purpose—retrieving a quiz from the database. The previous name, set_student_quiz, was less intuitive and didn’t clearly convey the action of retrieving a quiz. The name fetch_quiz also adheres to common naming conventions, making it easier to understand at a glance.

<b>4) Implement self.assessment in Review Response Map </b>

<div style="display:flex; justify-content:center; gap:20px; align-items:flex-start;">
<div style="text-align:center;">
'''app/models/review_response_map.rb'''
[[File:student_quiz10.png|600px]]
</div>
</div>

By implementing this class method self.assessments_for, the logic for retrieving all assessments for a reviewee is encapsulated, making it reusable and easier to call from other parts of the codebase.

==Implementation Details==

<b>1) Refactoring and Moving Business Logic</b> <br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the create_score method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/31e2b94777e833961124b24fa18a4923c4e344f7) (Refactoring the process_answers method)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/233e8449d80fedff4797b38549c974ab82586d9c) (Reimplementing the findResource in a different file)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/adf3b13b5b21cfa1f25ad5199e2027b37237c398) (Reimplementing the self.assessment in Review Response Map)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/b9418c9c705916c95bda3107134a6225effd9869) (Fixing method names in student_quizzes_controller.rb)
<br>

<b>2) Error Fixes</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/77e448591711ea5f0fc3ec1a718ded0589bfe166) (Response Map error fix)
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/000694b8ced3b667762eeac01c7fcea76b74dd49) (Fixing the Assignment Dependency)
<br>

<b>3) RSpec</b>
<br>
(https://github.com/Kiraschild/reimplementation-back-end/commit/1e22637ed9ab350ac1e75ef5607ea8d4bdd7edd2) (Adding Rspec Tests)
<br>
RSpec tests were added to validate the new methods and ensure the business logic for managing waitlist teams functions correctly.

== Test Plan ==
As outlined above, we refactored three key files. To ensure comprehensive coverage and maintain system reliability, we have implemented thorough testing for all affected components. This includes both unit and request tests, which are written using RSpec. The test coverage has been added to the following files:

* <code>spec/requests/api/v1/student_quizzes_controller_spec.rb</code>
* <code>spec/requests/api/v1/find_resource_service_spec.rb</code>
* <code>spec/services/api/v1/resource_map_spec.rb</code>

=== Pre-Test Setup ===

* Hierarchical roles are created using create_roles_hierarchy : <code>@roles = create_roles_hierarchy</code>
* Users with appropriate roles are instantiated for test scenarios.

JWT is used in tests to pretend a real user is logged in so we can check if only the right people can access certain API actions. It helps test authentication and authorization properly.<syntaxhighlight lang="ruby">

let(:token) { JsonWebToken.encode({ id: instructor.id }) }
let(:auth_headers) { { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" } }

</syntaxhighlight>

=== Testing ===
After the setup and authentication, we test each refactored file method. Below is an example of testing <code>index</code> Method in <code>StudentQuizzesController</code>.

'''Purpose''': Retrieve a list of all quizzes.

'''Test''': Validates that the endpoint returns a 200 OK status and a JSON array of quizzes.

<syntaxhighlight lang="ruby">
describe '#index' do
it "returns a list of quizzes" do
Questionnaire.create!(name: "Quiz One", instructor_id: instructor.id,
min_question_score: 0, max_question_score: 10)
get '/api/v1/student_quizzes', headers: auth_headers
expect(response).to have_http_status(:ok)
quizzes = JSON.parse(response.body)
expect(quizzes).to be_an(Array)
end
end
</syntaxhighlight>

Below are the complete tables that list our full test plans.

==== Tests for <code>student_quizzes_controller_spec.rb</code> ====

{| class="wikitable"
! Test Name !! HTTP Method !! Endpoint/ Method !! Action !! Purpose !! Tests
|-
| index || GET || /api/v1/student_quizzes || #index || Fetch all quizzes || Creates a sample quiz.<br>Sends a GET request to fetch quizzes.<br>Expects 200 OK and validates the response is an array.
|-
| create || POST || /api/v1/student_quizzes || #create || Create a new quiz || Prepares quiz parameters with nested questions and answers.<br>Sends a POST request to create a new quiz.<br>Expects 201 Created and checks for 'name' and 'questions' in response.
|-
| destroy || DELETE || /api/v1/student_quizzes/:id || #destroy || Delete a quiz || Creates a quiz record.<br>Sends a DELETE request to remove the quiz.<br>Expects 204 No Content and confirms quiz is deleted from the database.
|-
| show || GET || /api/v1/student_quizzes/:id || #show || Show quiz details || Creates a quiz record.<br>Sends a GET request to fetch the quiz by ID.<br>Expects 200 OK and validates the quiz's name and ID in the response.
|-
| assign_quiz || POST || /api/v1/student_quizzes/assign || #assign_quiz || Assign quiz to a participant || Assigns a quiz to a Participant model instance.<br>Sends a POST request to the assign endpoint.<br>Verifies 201 Created status.
|-
| submit_quiz || POST || /api/v1/student_quizzes/submit_answers || #submit_quiz || Submit answers || Creates a quiz and a corresponding response map.<br>Sends quiz answer submission via POST request.<br>Checks for 200 OK and validates 'total_score' is present in response.
|-
| update || PUT || /api/v1/student_quizzes/:id || #update || Update quiz || Creates a quiz with an initial name.<br>Sends a PUT request with updated name.<br>Expects 200 OK and checks that the name is updated in the response.
|-
| fetch_quiz || GET || /api/v1/student_quizzes/:id || #fetch_quiz || Fetch quiz using fetch_quiz method || Creates a quiz record.<br>Sends a GET request using fetch_quiz logic.<br>Expects 200 OK and validates the quiz's name in response.
|-
| render_success || GET || /api/v1/student_quizzes || #render_success || Render success response || Calls an action that invokes render_success (index).<br>Sends a GET request and expects 200 OK response.
|-
| create_questionnaire || POST || /api/v1/student_quizzes || #create_questionnaire || Create questionnaire || Sends a POST request with questionnaire attributes.<br>Checks if the questionnaire is created and returns 201 Created.<br>Validates the name in the response.
|-
| questionnaire_params || N/A || questionnaire_params(params) || #questionnaire_params || Extract strong parameters || Validates strong parameter extraction logic.<br>Handles valid, missing, and invalid parameters.<br>Raises ActionController::ParameterMissing when necessary.
|-
| create_questions_and_answers || N/A || create_questions_and_answers(questionnaire, questions_attributes) || #create_questions_and_answers || Build nested resources || Creates a questionnaire object.<br>Calls the method with nested question and answer attributes.<br>Validates that questions and answers are successfully saved.
|-
| render_error || N/A || render_error(message, status) || #render_error || Render error response || Triggers an action with invalid parameters.<br>Checks that 422 Unprocessable Entity is returned.<br>Validates the presence of an error message in the response.
|-
| quiz_assigned? || N/A || quiz_assigned?(participant, quiz) || #quiz_assigned? || Check quiz assignment || Checks if a quiz has already been assigned to a participant.<br>Returns true or false based on assignment existence and input validity.
|-
| build_response_map || N/A || build_response_map(quiz, participant) || #build_response_map || Create response map || Creates a quiz and participant.<br>Builds a ResponseMap and checks attributes.<br>Returns nil when quiz or participant is missing.
|-
| check_instructor_role || N/A || check_instructor_role || #check_instructor_role || Role verification || Checks if current user is an instructor.<br>Returns true if user has instructor role, false otherwise.
|}

==== Tests for <code>resource_map_spec.rb</code> ====

{| class="wikitable"
! Test Name !! Method !! Action !! Purpose !! Tests
|-
| calculate_score || calculate_score || #calculate_score || Calculate the score based on associated responses. || Mocks a response with a known score.<br>Calls `calculate_score` on the response_map.<br>Expects the calculated score to match.
|-
| find_or_initialize_response || find_or_initialize_response(questionnaire) || #find_or_initialize_response || Retrieve an existing response or initialize a new one for the given questionnaire. || Checks if a response already exists and returns it.<br>If none exists, it initializes a new response with the questionnaire.
|-
| get_score || get_score(questionnaire) || #get_score || Fetch the score from a response for a specific questionnaire. || Mocks a score and ensures `get_score` returns it.<br>Returns nil if there is no associated response.
|-
| process_answers || process_answers || #process_answers || Process answers in the associated response and update state. || Mocks success and failure conditions of answer processing.<br>Returns true or false accordingly.
|-
| build_response_map || build_response_map(questionnaire, participant) || #build_response_map || Create and return a response map for a given questionnaire and participant. || Creates and returns a valid ResponseMap object.<br>Returns nil if either questionnaire or participant is not valid.
|-
| find_for_current_user || find_for_current_user(user) || #find_for_current_user || Locate the response map associated with the current user. || Returns the existing response map if present.
|}

Beside those, we test <code>FindResourceService</code> that can be found in <code> find_resource_service_spec.rb</code>

==Next Steps==

* We will implement the feature that lets students skip quiz questions, including updating the rubric model and UI to support it properly.

* We plan to move score calculation logic from the response map to the response object to better support cases where users take the quiz multiple times.

* The current test coverage is 69.72%; we are confident of increasing the test coverage by implementing all of our test plans.

==Github Pull Request==
https://github.com/expertiza/reimplementation-back-end/pull/180

==Mentor==

* Anish Toorpu ([mailto:atoorpu@ncsu.edu atoorpu@ncsu.edu])

==Team Members==

* Kavya Lalbahadur Joshi ([mailto:kjoshi4@ncsu.edu kjoshi4@ncsu.edu])
* Vedant Patel ([mailto:vpatel32@ncsu.edu vpatel@ncsu.edu])
* Uchswas Paul ([mailto:upaul@ncsu.edu upaul@ncsu.edu])

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T01:09:33Z

Kjoshi4: /* Sequence of Actions in Assigning a Quiz */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T01:09:26Z

Kjoshi4: /* UML Diagram */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T01:07:12Z

Kjoshi4:

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:55:23Z

Kjoshi4: /* Changes Implemented */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:54:53Z

Kjoshi4: /* Changes Implemented */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:54:16Z

Kjoshi4: /* Changes Implemented */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:53:55Z

Kjoshi4: /* Changes Implemented */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:52:00Z

Kjoshi4: /* Changes Implemented */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:47:56Z

Kjoshi4:

File:Student quizzes UML.png

2025-04-08T00:46:17Z

Kjoshi4:

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:27:24Z

Kjoshi4: /* Sequence of Actions in Submitting Quiz Answers */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:27:16Z

Kjoshi4: /* Sequence of Actions in Assigning a Quiz */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:26:57Z

Kjoshi4: /* Sequence of Actions in Submitting Quiz Answers */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:26:28Z

Kjoshi4: /* Sequence of Actions in Assigning a Quiz */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:25:57Z

Kjoshi4: /* Key Features */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:25:36Z

Kjoshi4:

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:15:12Z

Kjoshi4: /* Key Features */

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-08T00:11:34Z

Kjoshi4:

CSC/ECE 517 Spring 2025

2025-04-07T21:13:05Z

Kjoshi4: /* Final Projects */

* [[CSC/ECE 517 Spring 2025 - E2503. Refactor the Team hierarchy]]
* [[CSC/ECE 517 Spring 2025 - E2504. Mentor-meeting management]]
* [[CSC/ECE 517 Spring 2025 - E2505. Testing Answer Tagging]]
* [[CSC/ECE 517 Spring 2025 - E2508. Reimplement bidding-algorithm web service]]
* [[CSC/ECE 517 Spring 2025 - E2509. Reimplement feedback_response_map.rb]]
* [[CSC/ECE 517 Spring 2025 - E2519. Implement view for results of bidding]]
* [[CSC/ECE 517 Spring 2025 - E2522. Enhancing UI Consistency in Expertiza 1]]
* [[CSC/ECE 517 Spring 2025 - E2520. Reimplement heatgrid UI for reviews]]
* [[CSC/ECE 517 Spring 2025 - E2517. Reimplement internationalization (frontend + backend)]]
* [[CSC/ECE 517 Spring 2025 - E2523: Enhancing UI Consistency in Expertiza 2]]
* [[CSC/ECE 517 Spring 2025 - E2515: Reimplement student_teams_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2501: Refactor review_mapping_helper.rb]]
* [[CSC/ECE 517 Spring 2025 - E2502: Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2512. Reimplement responses controller]]
* [[CSC/ECE 517 Spring 2025 - E2510. Reimplement grades_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2507. Reimplement back end for submission records]]
* [[CSC/ECE 517 Spring 2025 - E2514. Reimplement student_quizzes_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2518. Reimplement password resets (frontend + backend)]]
* [[CSC/ECE 517 Spring 2025 - E2516. Reimplement teams_users_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2511. Reimplement participants_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2521. UI for View submissions/assign grades (except heatgrid)]]
* [[CSC/ECE 517 Spring 2025 - E2513. Reimplement sign_up_topic.rb as project_topic.rb]]
* [[CSC/ECE 517 Spring 2025 - E2506. Implement testing for new Bookmarks Controller]]
* [[CSC/ECE 517 Spring 2025 - E2527. Mentor-meeting management: assignments with topics]]

== Final Projects ==
* [[CSC/ECE 517 Spring 2025 - E2509 Refactoring and Enhancing the Feedback Response Map Controller]]
* [[CSC/ECE 517 Spring 2025 - E2539 Reimplement Student Task View (Frontend + Backend)]]
* [[CSC/ECE 517 Spring 2025 - E2521 UI for View submissions/assign grades (except heatgrid)]]
* [[CSC/ECE 517 Spring 2025 - E2524 Reimplement student review controller]]
* [[CSC/ECE 517 Spring 2025 - E2525 Reimplement review_mapping_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2526 Reimplement Teams and Participant hierarchies]]
* [[CSC/ECE 517 Spring 2025 - E2530 Reimplement Grades Controller (Frontend + Backend)]]
* [[CSC/ECE 517 Spring 2025 - E2538 Reimplementing Questionnaire Page in Expertiza]]
* [[CSC/ECE 517 Spring 2025 - E2534 UI for Assign Reviewers]]
* [[CSC/ECE 517 Spring 2025 - E2540 Integration of Assignment participant Frontend with participant controller Backend]]
* [[CSC/ECE 517 Spring 2025 - E2532. Reimplement Missing ResponseMap Subclasses]]
* [[CSC/ECE 517 Spring 2025 - E2542. Refactor review_bids_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2533. Reimplement the Team hierarchy]]
* [[CSC/ECE 517 Spring 2025 - E2531 Refactor participants_controller.rb]]
* [[CSC/ECE 517 Spring 2025 - E2528 Testing for Survey Deployment]]
* [[CSC/ECE 517 Spring 2025 - E2514. Reimplement student_quizzes_controller.rb]]

CSC/ECE 517 Spring 2025 - E2514. Reimplement student quizzes controller.rb

2025-04-07T18:52:47Z

Kjoshi4: