CSC/ECE 517 Fall 2023: E2367. Reimplement participants controller.rb, participants.rb and its child classes
This wiki page is for the description of changes made under E2367 OSS assignment for Fall 2023, CSC/ECE 517
Introduction
Expertiza is a prominent open-source project founded on the Ruby on Rails framework, serving as a collaborative effort between the faculty and students of NC State. This web application facilitates instructors in generating customized assignments, including both new and existing tasks. Additionally, instructors can establish a roster of topics for student enrollment. Within Expertiza, students have the ability to form teams for collaborative work on various projects and assignments. An integral aspect of the platform is the provision for students to conduct peer reviews of their peers' submissions.
Distinguished by its support for a diverse array of document types, Expertiza enables submission of various formats such as URLs and wiki pages. Serving as an open-source learning management system developed using Ruby on Rails, Expertiza embodies an extensive suite of functionalities that empower students to submit and engage in peer review processes encompassing various learning objects like articles, codes, and websites. Instructors wield the capability to oversee and assess the submissions made by students through the platform. Expertiza is instrumental in facilitating instructors and teaching assistants in managing assignments for the courses they administer.
Overview of the Classes
participants_controller.rb:
The ParticipantsController is responsible for managing participants in an application. Participants can be associated with either "Course" or "Assignment" models. It handles actions related to creating, updating, retrieving, and deleting participants. Inherit copies existing participants from a course down to its assignment while bequeath copies existing participants from an assignment up to its course. It has two private methods namely copy_participants_from_source_to_target which copies participants from source to target and participant_params.
assignment_participant.rb:
The assignment_participant.rb is a model class that has many associations including ‘assignment’. This association signifies that an AssignmentParticipant belongs to a specific assignment. The AssignmentParticipant class includes several attributes such as avg_vol_per_round, overall_avg_vol and handle that are vital for its functionality. There are many methods present which collectively facilitate various actions and operations related to managing participants in assignments, including reviewing, copying, importing, and handling file paths and deadlines. They include review_file_path, current_stage, stage_deadline, current_user_is_reviewer, reviews, dir_path, etc. There are also a couple of methods that use digital signatures such as assign_copyright and verify_digital_signature.
course_participant.rb:
The course_participant model has a class named CourseParticipant that inherits from a class called Participant. It is used to manage participants in courses, allowing for copying participants to assignments and importing new participants into a course. It consists of three methods namely copy, import and path. Copy creates a copy of a course participant for an assignment. Path method returns the path of the course participant while self.import method is used for importing course participants by taking row_hash, session, and id as parameters.
Background of the Project
The Expertiza project involves the reimplementing of the participants_controller.rb and participants.rb files, along with their respective child classes. The previous iteration of the participant model and controller underwent reimplementations in prior semesters, resulting in tests that relied extensively on mocks and stubs due to missing components.
The participants_controller.rb file encapsulates various methods and functionalities vital to managing participants within the system. This includes actions like adding, updating, and deleting participants, inheriting participants from courses to assignments, bequeathing participants from assignments to courses, changing participant handles, viewing copyright grants, and more. The controller makes use of helper functions, associations, and delegate methods to streamline participant operations.
Meanwhile, the course_participants.rb file extends the functionality of the base participant class, focusing on operations specific to course participants. This includes copying participants to assignments, importing course participants, and defining paths for course participants within the project.
The base participant.rb file defines the fundamental structure and behavior for all participants in the system, including shared associations, delegate methods, and validations. The file incorporates methods related to participant handling, user information retrieval, email functionalities, authorization, sorting, and export functionality.
The project's primary objective revolves around enhancing the reliability and functionality of the participant-related components, thereby fortifying the overall system's capabilities and improving the testing process to ensure robustness and stability within the Expertiza platform.
The reimplementation must make sense; when reviewing the original model, we discovered that certain functions were unnecessary for the controller class and model in question and needed to be implemented in a different model. The majority of the adjustments were made to separate methods with a single capability pertinent to certain classes by deleting, combining, and replacing methods.To improve readability, notes are provided to every technique. The discussion of the reimplementations continues below with further details.
Design Decisions
participants_controller.rb:
We have reimplemented participants_controller.rb by making following changes:
1) Changed function name: The function name 'copy_participants_from_source_to_target' has been renamed to 'copy_participants' as original name was too long.
2) Improved Code Comments: The code has detailed comments for each action method, the purpose of the method and the expected parameters. The parameters for each action method are explicitly defined in comments, making it clear which parameters are expected.
3) Improved Error Handling: Exceptions are caught more specifically (e.g., StandardError) to provide better error messages.
4) Refactored delete Method: The destroy method has been refactored to use participant.delete(false) to avoid accidental deletion and provides better error handling.
5) Consistent Status Codes: The code uses consistent HTTP status codes for responses, for example, using status: :not_found for a resource not found.
6) Consistent JSON Response Format: The JSON responses are structured consistently, with keys like "model_object" and "participants," making it easier for clients to consume the API.
assignment_participant.rb:
This is the reimplemented AssignmentParticipant class. It is a subclass of the Participant class and includes additional functionalities and methods specific to participants assigned to an assignment in the system.
In the `assignment_participant.rb` class, several changes and improvements have been made to enhance the readability and maintainability of the code. Here are the specific modifications made:
1. Removed certain comments and obsolete code for better readability and clarity.
2. Introduced the safe navigation operator (`&.`) in several places to avoid nil errors, particularly in cases where object references may be nil.
3. Simplified certain methods, such as `reviewers` and `feedback`, for cleaner and more readable code.
4. Improved string formatting for directory paths and file paths to enhance readability.
5. Enhanced error handling in the `import` method to provide more informative error messages and handle exceptional cases more gracefully.
These changes aim to make the code more maintainable and concise while ensuring that the functionality and integrity of the `AssignmentParticipant` class remain intact.
course_participant.rb:
The following changes were reimplemented in the course_participant.rb
In the CourseParticipant class, several changes and improvements have been made to enhance the readability and maintainability of the code. Here are the specific modifications made:
1] The copy method has been simplified using the find_or_create_by method, which helps to find an existing record or create a new one if it doesn't exist.
2] In the import method, the find_or_create_by method has been used to both find or create a user and find or create a course participant. This helps to streamline the process and handle the cases where the records may or may not exist.
3] The path method has been refactored to use the safe navigation operator (&.) to avoid potential nil errors during the construction of the path. This ensures that the code is more robust and handles potential null references gracefully.
These changes aim to make the code more concise and readable, without compromising the functionality or integrity of the CourseParticipant class.
Testing Plan
Note:
The new code uses the describe and it syntax extensively for specifying behavior, whereas the old code uses RSpec.describe and context for the same purpose. Both are valid ways of structuring RSpec tests, but the new code seems to follow a slightly different convention. 1)The test case names in the new code are more descriptive and follow a consistent pattern using underscores, making them easier to understand.
2)The new code uses FactoryBot's build method for creating instances of various models, such as build(:assignment), build(:course_participant), etc. This is a good practice for creating test data.
3)The #copy method in the new code uses the allow and expect syntax to set up and verify expectations on method calls. It also explicitly checks if the copy exists and returns nil in one of the test cases.
4)The #import method in the new code now raises specific errors for different scenarios, providing more detailed information about what went wrong. It also explicitly checks for the existence of a course with a given ID.
5)The #export method in the new code writes to a CSV file using CSV.open and checks if the file is created. This is a more explicit way of testing file creation.
6)The #export_fields method in the new code explicitly checks if the fields are empty or not based on the provided options.
7)In the previous code, there are variables like user, course, and assignment that are defined but not used in the relevant test cases.
8)The new code has consistent indentation and formatting, making it more readable. Additionally, the new code has removed unnecessary comments and placeholders present in the old code.
9)The new code does not use type: :model as metadata for RSpec tests. This metadata is often used to specify the type of test (e.g., model, controller, feature).
Tests:
| Test No. | Description |
|---|---|
| 1 | Tests if a copy of the participant is created |
| 2 | Tests if copy exists then return nil |
| 3 | Tests if the record is empty then raise an error |
| 4 | Tests if the record does not have enough items then raises error |
| 5 | Tests if course with id not found |
| 6 | Tests to create course participant form record |
| 7 | Tests if csv file is created |
| 8 | Tests if option is empty if fields is empty |
| 9 | Tests if option is not empty if fields is not empty |
Relevant Links
Github repository: https://github.com/krishna5701/reimplementation-back-end
Pull request: https://github.com/expertiza/reimplementation-back-end/pull/49
Team
Mentor
Devashish Vachhani
Student Team
1] Krishna Patel (kpatel43@ncsu.edu)
2] Janhavi Pendse (jspendse@ncsu.edu)
3] Payal Mehta (pmehta5@ncsu.edu)