Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-05-04T19:42:08Z

Zobrook2:

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

*'''Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]'''

*'''QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]'''

*'''Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]'''

'''Question Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questions_table]'''

Questions are referred to as "Items" in some of the test cases. While they aren't being directly covered by test cases, factories for the Question Model are needed so that the relationship between Questionnaire and QuestionAdvice are properly connected. The Questionnaire model has a one-many relationship with the Questions model, where a Questionnaire can have many Questions while each Question belongs to a single Questionnaire. The QuestionAdvice model has a one-one relationship with the Question model and a QuestionAdvice entry belongs to a single Question.

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

==== 1. validate_questionnaire ====
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<syntaxhighlight lang="ruby">
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</syntaxhighlight>

====2. self.copy_questionnaire_details====
Clones a questionnaire, including its items and associated advice.

<syntaxhighlight lang="ruby">
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</syntaxhighlight>

====3. check_for_question_associations====
Checks whether the questionnaire has associated items before deletion.

<syntaxhighlight lang="ruby">
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</syntaxhighlight>

====4. get_weighted_score====
Calculates the weighted score by generating a symbol and calling a helper method.

<syntaxhighlight lang="ruby">
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</syntaxhighlight>

====5. compute_weighted_score====
Helper method that computes the weighted score for an assignment.

<syntaxhighlight lang="ruby">
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</syntaxhighlight>

====6. true_false_items?====
Checks if the questionnaire contains any true/false (checkbox) items.

<syntaxhighlight lang="ruby">
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</syntaxhighlight>

====7. max_possible_score====
Calculates the maximum possible score based on item weights and max question score.

<syntaxhighlight lang="ruby">
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</syntaxhighlight>

=== QuestionAdvice Model Methods ===

====1. self.export_fields====
Returns all column names of QuestionAdvice as strings.

<syntaxhighlight lang="ruby">
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</syntaxhighlight>

====2. self.export====
Exports QuestionAdvice entries to a CSV file.

<syntaxhighlight lang="ruby">
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</syntaxhighlight>

====3. self.to_json_by_question_id====
Exports QuestionAdvice entries to JSON format by question ID.

<syntaxhighlight lang="ruby">
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</syntaxhighlight>

=== Course Model Methods ===

====1. path====
Returns the submission directory path for the course.

<syntaxhighlight lang="ruby">
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</syntaxhighlight>

====2. add_ta====
Adds a Teaching Assistant (TA) to the course.

<syntaxhighlight lang="ruby">
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</syntaxhighlight>

====3. remove_ta====
Removes a Teaching Assistant from the course.

<syntaxhighlight lang="ruby">
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</syntaxhighlight>

====4. copy_course====
Creates a duplicate of the course.

<syntaxhighlight lang="ruby">
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</syntaxhighlight>

== Test Design ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<syntaxhighlight lang="ruby">
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</syntaxhighlight>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<syntaxhighlight lang="ruby">
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</syntaxhighlight>

==== Course ====

The following code is the current version of the factory for the course models.

<syntaxhighlight lang="ruby">
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</syntaxhighlight>

==== QuestionAdvice ====

For QuestionAdvice use factories to load data into database to test that it is being saved and exported properly.

<syntaxhighlight lang="ruby">
# spec/factories/question_advice.rb
FactoryBot.define do
factory :question_advice do
score {5}
association :item
advice {'default advice'}
end
end
</syntaxhighlight>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

The following steps can be used to run only the tests relevant to this project.

In <code>spec_helper.rb</code>:

1. Add the following line to the require section:

<syntaxhighlight lang="ruby">
require 'simplecov-html'
</syntaxhighlight>

2. Modify the SimpleCov.formatter assignment to be the following:

<syntaxhighlight lang="ruby">
SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
SimpleCov::Formatter::HTMLFormatter,
SimpleCov::Formatter::JSONFormatter
])
</syntaxhighlight>

3. Replace the <code>if !ENV['COVERAGE_STARTED']</code> block with the following:

<syntaxhighlight lang="ruby">
if !ENV['COVERAGE_STARTED']
SimpleCov.start 'rails' do
track_files 'app/models/{questionnaire,question_advice,course}.rb'
tracked = %w[
app/models/questionnaire.rb
app/models/question_advice.rb
app/models/course.rb
].map { |path| File.expand_path(path, SimpleCov.root) }

add_filter do |src|
!tracked.include?(src.filename)
end
end
ENV['COVERAGE_STARTED'] = 'true'
end
</syntaxhighlight>

Then, run the test suite using the following:

<syntaxhighlight lang="ruby">
bundle exec rspec spec/models/questionnaire_spec.rb spec/models/course_spec.rb spec/models/question_advice_spec.rb
</syntaxhighlight>

== Results ==

=== Coverage ===

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

=== Bugs Fixed ===

==== Handling Nil User in add_ta Method (Course Model) ====
A bug was identified in the <code>Course</code> model where the <code>add_ta</code> method would crash when a <code>nil</code> user was passed during unit testing. The issue occurred because the method attempted to access <code>user.id</code> without first verifying that the user object was present.

To prevent this runtime error, the method was updated to safely handle <code>nil</code> inputs using safe navigation (<code>&.id</code>) and an early return pattern.

Fixed implementation:

<syntaxhighlight lang="ruby">
# Add a Teaching Assistant to the course
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user&.id} does not exist" }
elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }
else
# remaining logic...
end
end
</syntaxhighlight>

This fix ensures that the method no longer raises exceptions when a <code>nil</code> user is provided and instead returns a controlled error response, improving robustness and test reliability.

==== Corrected Course–User Association Mapping ====
A bug in the <code>Course</code> model was fixed where the <code>users</code> association incorrectly referenced a non-existent relationship (<code>course_participants</code>). The model already defines the correct join association as <code>participants</code>, so the additional reference caused confusion and potential runtime issues.

The association structure correctly uses <code>CourseParticipant</code> through <code>participants</code>, and <code>users</code> should be derived from this relationship.

Before fix:
<syntaxhighlight lang="ruby">
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</syntaxhighlight>

Correct association structure:
<syntaxhighlight lang="ruby">
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :participants
</syntaxhighlight>

This fix ensures that the <code>users</code> association correctly resolves through the existing <code>participants</code> relationship, maintaining consistency in the model and preventing invalid association lookups.

==== Correct Foreign Key Mapping for QuestionAdvice Association ====
A fix was applied to the <code>QuestionAdvice</code> model to ensure the association correctly references the underlying database schema.

Previously, Rails was implicitly expecting a default foreign key (<code>item_id</code>), which did not match the actual schema. The <code>question_advice</code> table stores the foreign key as <code>question_id</code>, meaning the association must explicitly specify this key to function correctly.

To resolve this mismatch, the association was updated as follows:

<syntaxhighlight lang="ruby">
class QuestionAdvice < ApplicationRecord
belongs_to :item, foreign_key: :question_id
# remaining logic...
end
</syntaxhighlight>

This change ensures that Rails correctly maps each <code>QuestionAdvice</code> record to its associated <code>Item</code> using <code>question_id</code>, restoring proper association behavior and preventing incorrect lookups using the default key.

==== Fixing Invalid ID Reference in remove_ta Method ====
A bug was discovered in the remove_ta implementation within the Course model where the method was failing to locate existing TaMapping records. The issue was caused by passing the symbol :id as a parameter instead of the actual local id variable.

Because ActiveRecord treats symbols in query hashes literally, it attempted to find a record where the course_id was the literal string/symbol "id", rather than the integer ID of the course instance. This bug was previously masked in the test suite by heavy mocking of find_by and where. By removing the mocks and using actual database records in the test refactor, the failure was exposed.

Before fix:

<syntaxhighlight lang="ruby">
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
</syntaxhighlight>

Fixed implementation:

<syntaxhighlight lang="ruby">
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: id)
</syntaxhighlight>

This update ensures the query correctly references the course's unique identifier, allowing remove_ta to successfully locate and remove the mapping and subsequently update the user's role.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-28T22:30:20Z

Zobrook2: /* Running Tests */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

*'''Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]'''

*'''QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]'''

*'''Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]'''

'''Question Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questions_table]'''

Questions are referred to as "Items" in some of the test cases. While they aren't being directly covered by test cases, factories for the Question Model are needed so that the relationship between Questionnaire and QuestionAdvice are properly connected. The Questionnaire model has a one-many relationship with the Questions model, where a Questionnaire can have many Questions while each Question belongs to a single Questionnaire. The QuestionAdvice model has a one-one relationship with the Question model and a QuestionAdvice entry belongs to a single Question.

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Test Design ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use factories to load data into database to test that it is being saved and exported properly.

<pre>
# spec/factories/question_advice.rb
FactoryBot.define do
factory :question_advice do
score {5}
association :item
advice {'default advice'}
end
end</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

The following steps can be used to run only the tests relevant to this project.

In <code>spec_helper.rb</code>:

1. Add the following line to the require section:

<syntaxhighlight lang="ruby">
require 'simplecov-html'
</syntaxhighlight>

2. Modify the SimpleCov.formatter assignment to be the following:

<syntaxhighlight lang="ruby">
SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
SimpleCov::Formatter::HTMLFormatter,
SimpleCov::Formatter::JSONFormatter
])
</syntaxhighlight>

3. Replace the <code>if !ENV['COVERAGE_STARTED']</code> block with the following:

<syntaxhighlight lang="ruby">
if !ENV['COVERAGE_STARTED']
SimpleCov.start 'rails' do
track_files 'app/models/{questionnaire,question_advice,course}.rb'
tracked = %w[
app/models/questionnaire.rb
app/models/question_advice.rb
app/models/course.rb
].map { |path| File.expand_path(path, SimpleCov.root) }

add_filter do |src|
!tracked.include?(src.filename)
end
end
ENV['COVERAGE_STARTED'] = 'true'
end
</syntaxhighlight>

Then, run the test suite using the following:

<syntaxhighlight lang="ruby">
bundle exec rspec spec/models/questionnaire_spec.rb spec/models/course_spec.rb spec/models/question_advice_spec.rb
</syntaxhighlight>

== Results ==

=== Coverage ===

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

=== Bugs Fixed ===

==== Handling Nil User in add_ta Method (Course Model) ====
A bug was identified in the <code>Course</code> model where the <code>add_ta</code> method would crash when a <code>nil</code> user was passed during unit testing. The issue occurred because the method attempted to access <code>user.id</code> without first verifying that the user object was present.

To prevent this runtime error, the method was updated to safely handle <code>nil</code> inputs using safe navigation (<code>&.id</code>) and an early return pattern.

Fixed implementation:

<pre>
# Add a Teaching Assistant to the course
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user&.id} does not exist" }
elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }
else
# remaining logic...
end
end
</pre>

This fix ensures that the method no longer raises exceptions when a <code>nil</code> user is provided and instead returns a controlled error response, improving robustness and test reliability.

==== Corrected Course–User Association Mapping ====
A bug in the <code>Course</code> model was fixed where the <code>users</code> association incorrectly referenced a non-existent relationship (<code>course_participants</code>). The model already defines the correct join association as <code>participants</code>, so the additional reference caused confusion and potential runtime issues.

The association structure correctly uses <code>CourseParticipant</code> through <code>participants</code>, and <code>users</code> should be derived from this relationship.

Before fix:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

Correct association structure:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :participants
</pre>

This fix ensures that the <code>users</code> association correctly resolves through the existing <code>participants</code> relationship, maintaining consistency in the model and preventing invalid association lookups.

==== Correct Foreign Key Mapping for QuestionAdvice Association ====
A fix was applied to the <code>QuestionAdvice</code> model to ensure the association correctly references the underlying database schema.

Previously, Rails was implicitly expecting a default foreign key (<code>item_id</code>), which did not match the actual schema. The <code>question_advice</code> table stores the foreign key as <code>question_id</code>, meaning the association must explicitly specify this key to function correctly.

To resolve this mismatch, the association was updated as follows:

<pre>
class QuestionAdvice < ApplicationRecord
belongs_to :item, foreign_key: :question_id
# remaining logic...
end
</pre>

This change ensures that Rails correctly maps each <code>QuestionAdvice</code> record to its associated <code>Item</code> using <code>question_id</code>, restoring proper association behavior and preventing incorrect lookups using the default key.

==== Fixing Invalid ID Reference in remove_ta Method ====
A bug was discovered in the remove_ta implementation within the Course model where the method was failing to locate existing TaMapping records. The issue was caused by passing the symbol :id as a parameter instead of the actual local id variable.

Because ActiveRecord treats symbols in query hashes literally, it attempted to find a record where the course_id was the literal string/symbol "id", rather than the integer ID of the course instance. This bug was previously masked in the test suite by heavy mocking of find_by and where. By removing the mocks and using actual database records in the test refactor, the failure was exposed.

Before fix:

<pre>
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
</pre>

Fixed implementation:

<pre>
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: id)
</pre>

This update ensures the query correctly references the course's unique identifier, allowing remove_ta to successfully locate and remove the mapping and subsequently update the user's role.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-27T03:59:00Z

Zobrook2: /* Bugs Fixed */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

*'''Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]'''

*'''QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]'''

*'''Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]'''

'''Question Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questions_table]'''

Questions are referred to as "Items" in some of the test cases. While they aren't being directly covered by test cases, factories for the Question Model are needed so that the relationship between Questionnaire and QuestionAdvice are properly connected. The Questionnaire model has a one-many relationship with the Questions model, where a Questionnaire can have many Questions while each Question belongs to a single Questionnaire. The QuestionAdvice model has a one-one relationship with the Question model and a QuestionAdvice entry belongs to a single Question.

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Test Design ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

The following steps can be used to run only the tests relevant to this project.

In <code>spec_helper.rb</code>:

1. Add the following line to the require section:

<syntaxhighlight lang="ruby">
require 'simplecov-html'
</syntaxhighlight>

2. Modify the SimpleCov.formatter assignment to be the following:

<syntaxhighlight lang="ruby">
SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
SimpleCov::Formatter::HTMLFormatter,
SimpleCov::Formatter::JSONFormatter
])
</syntaxhighlight>

3. Replace the <code>if !ENV['COVERAGE_STARTED']</code> block with the following:

<syntaxhighlight lang="ruby">
if !ENV['COVERAGE_STARTED']
SimpleCov.start 'rails' do
track_files 'app/models/{questionnaire,question_advice,course}.rb'
tracked = %w[
app/models/questionnaire.rb
app/models/question_advice.rb
app/models/course.rb
].map { |path| File.expand_path(path, SimpleCov.root) }

add_filter do |src|
!tracked.include?(src.filename)
end
end
ENV['COVERAGE_STARTED'] = 'true'
end
</syntaxhighlight>

== Results ==

=== Coverage ===

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

=== Bugs Fixed ===

==== Handling Nil User in add_ta Method (Course Model) ====
A bug was identified in the <code>Course</code> model where the <code>add_ta</code> method would crash when a <code>nil</code> user was passed during unit testing. The issue occurred because the method attempted to access <code>user.id</code> without first verifying that the user object was present.

To prevent this runtime error, the method was updated to safely handle <code>nil</code> inputs using safe navigation (<code>&.id</code>) and an early return pattern.

Fixed implementation:

<pre>
# Add a Teaching Assistant to the course
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user&.id} does not exist" }
elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }
else
# remaining logic...
end
end
</pre>

This fix ensures that the method no longer raises exceptions when a <code>nil</code> user is provided and instead returns a controlled error response, improving robustness and test reliability.

==== Corrected Course–User Association Mapping ====
A bug in the <code>Course</code> model was fixed where the <code>users</code> association incorrectly referenced a non-existent relationship (<code>course_participants</code>). The model already defines the correct join association as <code>participants</code>, so the additional reference caused confusion and potential runtime issues.

The association structure correctly uses <code>CourseParticipant</code> through <code>participants</code>, and <code>users</code> should be derived from this relationship.

Before fix:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

Correct association structure:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :participants
</pre>

This fix ensures that the <code>users</code> association correctly resolves through the existing <code>participants</code> relationship, maintaining consistency in the model and preventing invalid association lookups.

==== Correct Foreign Key Mapping for QuestionAdvice Association ====
A fix was applied to the <code>QuestionAdvice</code> model to ensure the association correctly references the underlying database schema.

Previously, Rails was implicitly expecting a default foreign key (<code>item_id</code>), which did not match the actual schema. The <code>question_advice</code> table stores the foreign key as <code>question_id</code>, meaning the association must explicitly specify this key to function correctly.

To resolve this mismatch, the association was updated as follows:

<pre>
class QuestionAdvice < ApplicationRecord
belongs_to :item, foreign_key: :question_id
# remaining logic...
end
</pre>

This change ensures that Rails correctly maps each <code>QuestionAdvice</code> record to its associated <code>Item</code> using <code>question_id</code>, restoring proper association behavior and preventing incorrect lookups using the default key.

==== Fixing Invalid ID Reference in remove_ta Method ====
A bug was discovered in the remove_ta implementation within the Course model where the method was failing to locate existing TaMapping records. The issue was caused by passing the symbol :id as a parameter instead of the actual local id variable.

Because ActiveRecord treats symbols in query hashes literally, it attempted to find a record where the course_id was the literal string/symbol "id", rather than the integer ID of the course instance. This bug was previously masked in the test suite by heavy mocking of find_by and where. By removing the mocks and using actual database records in the test refactor, the failure was exposed.

Before fix:

<pre>
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
</pre>

Fixed implementation:

<pre>
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: id)
</pre>

This update ensures the query correctly references the course's unique identifier, allowing remove_ta to successfully locate and remove the mapping and subsequently update the user's role.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T16:39:38Z

Zobrook2: /* Issues in Initial Code */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Test Design ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

The following steps can be used to run only the tests relevant to this project.

In <code>spec_helper.rb</code>:

1. Add the following line to the require section:

<syntaxhighlight lang="ruby">
require 'simplecov-html'
</syntaxhighlight>

2. Modify the SimpleCov.formatter assignment to be the following:

<syntaxhighlight lang="ruby">
SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
SimpleCov::Formatter::HTMLFormatter,
SimpleCov::Formatter::JSONFormatter
])
</syntaxhighlight>

3. Replace the <code>if !ENV['COVERAGE_STARTED']</code> block with the following:

<syntaxhighlight lang="ruby">
if !ENV['COVERAGE_STARTED']
SimpleCov.start 'rails' do
track_files 'app/models/{questionnaire,question_advice,course}.rb'
tracked = %w[
app/models/questionnaire.rb
app/models/question_advice.rb
app/models/course.rb
].map { |path| File.expand_path(path, SimpleCov.root) }

add_filter do |src|
!tracked.include?(src.filename)
end
end
ENV['COVERAGE_STARTED'] = 'true'
end
</syntaxhighlight>

== Results ==

=== Coverage ===

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

=== Bugs Fixed ===

==== Handling Nil User in add_ta Method (Course Model) ====
A bug was identified in the <code>Course</code> model where the <code>add_ta</code> method would crash when a <code>nil</code> user was passed during unit testing. The issue occurred because the method attempted to access <code>user.id</code> without first verifying that the user object was present.

To prevent this runtime error, the method was updated to safely handle <code>nil</code> inputs using safe navigation (<code>&.id</code>) and an early return pattern.

Fixed implementation:

<pre>
# Add a Teaching Assistant to the course
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user&.id} does not exist" }
elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }
else
# remaining logic...
end
end
</pre>

This fix ensures that the method no longer raises exceptions when a <code>nil</code> user is provided and instead returns a controlled error response, improving robustness and test reliability.

==== Corrected Course–User Association Mapping ====
A bug in the <code>Course</code> model was fixed where the <code>users</code> association incorrectly referenced a non-existent relationship (<code>course_participants</code>). The model already defines the correct join association as <code>participants</code>, so the additional reference caused confusion and potential runtime issues.

The association structure correctly uses <code>CourseParticipant</code> through <code>participants</code>, and <code>users</code> should be derived from this relationship.

Before fix:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

Correct association structure:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :participants
</pre>

This fix ensures that the <code>users</code> association correctly resolves through the existing <code>participants</code> relationship, maintaining consistency in the model and preventing invalid association lookups.

==== Correct Foreign Key Mapping for QuestionAdvice Association ====
A fix was applied to the <code>QuestionAdvice</code> model to ensure the association correctly references the underlying database schema.

Previously, Rails was implicitly expecting a default foreign key (<code>item_id</code>), which did not match the actual schema. The <code>question_advice</code> table stores the foreign key as <code>question_id</code>, meaning the association must explicitly specify this key to function correctly.

To resolve this mismatch, the association was updated as follows:

<pre>
class QuestionAdvice < ApplicationRecord
belongs_to :item, foreign_key: :question_id
# remaining logic...
end
</pre>

This change ensures that Rails correctly maps each <code>QuestionAdvice</code> record to its associated <code>Item</code> using <code>question_id</code>, restoring proper association behavior and preventing incorrect lookups using the default key.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T07:22:16Z

Zobrook2: /* Bugs Fixed */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Design ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

The following steps can be used to run only the tests relevant to this project.

In <code>spec_helper.rb</code>:

1. Add the following line to the require section:

<syntaxhighlight lang="ruby">
require 'simplecov-html'
</syntaxhighlight>

2. Modify the SimpleCov.formatter assignment to be the following:

<syntaxhighlight lang="ruby">
SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
SimpleCov::Formatter::HTMLFormatter,
SimpleCov::Formatter::JSONFormatter
])
</syntaxhighlight>

3. Replace the <code>if !ENV['COVERAGE_STARTED']</code> block with the following:

<syntaxhighlight lang="ruby">
if !ENV['COVERAGE_STARTED']
SimpleCov.start 'rails' do
track_files 'app/models/{questionnaire,question_advice,course}.rb'
tracked = %w[
app/models/questionnaire.rb
app/models/question_advice.rb
app/models/course.rb
].map { |path| File.expand_path(path, SimpleCov.root) }

add_filter do |src|
!tracked.include?(src.filename)
end
end
ENV['COVERAGE_STARTED'] = 'true'
end
</syntaxhighlight>

== Results ==

=== Coverage ===

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

=== Bugs Fixed ===

==== Handling Nil User in add_ta Method (Course Model) ====
A bug was identified in the <code>Course</code> model where the <code>add_ta</code> method would crash when a <code>nil</code> user was passed during unit testing. The issue occurred because the method attempted to access <code>user.id</code> without first verifying that the user object was present.

To prevent this runtime error, the method was updated to safely handle <code>nil</code> inputs using safe navigation (<code>&.id</code>) and an early return pattern.

Fixed implementation:

<pre>
# Add a Teaching Assistant to the course
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user&.id} does not exist" }
elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }
else
# remaining logic...
end
end
</pre>

This fix ensures that the method no longer raises exceptions when a <code>nil</code> user is provided and instead returns a controlled error response, improving robustness and test reliability.

==== Corrected Course–User Association Mapping ====
A bug in the <code>Course</code> model was fixed where the <code>users</code> association incorrectly referenced a non-existent relationship (<code>course_participants</code>). The model already defines the correct join association as <code>participants</code>, so the additional reference caused confusion and potential runtime issues.

The association structure correctly uses <code>CourseParticipant</code> through <code>participants</code>, and <code>users</code> should be derived from this relationship.

Before fix:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

Correct association structure:
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :participants
</pre>

This fix ensures that the <code>users</code> association correctly resolves through the existing <code>participants</code> relationship, maintaining consistency in the model and preventing invalid association lookups.

==== Correct Foreign Key Mapping for QuestionAdvice Association ====
A fix was applied to the <code>QuestionAdvice</code> model to ensure the association correctly references the underlying database schema.

Previously, Rails was implicitly expecting a default foreign key (<code>item_id</code>), which did not match the actual schema. The <code>question_advice</code> table stores the foreign key as <code>question_id</code>, meaning the association must explicitly specify this key to function correctly.

To resolve this mismatch, the association was updated as follows:

<pre>
class QuestionAdvice < ApplicationRecord
belongs_to :item, foreign_key: :question_id
# remaining logic...
end
</pre>

This change ensures that Rails correctly maps each <code>QuestionAdvice</code> record to its associated <code>Item</code> using <code>question_id</code>, restoring proper association behavior and preventing incorrect lookups using the default key.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T06:14:10Z

Zobrook2:

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Design ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

The following steps can be used to run only the tests relevant to this project.

In <code>spec_helper.rb</code>:

1. Add the following line to the require section:

<syntaxhighlight lang="ruby">
require 'simplecov-html'
</syntaxhighlight>

2. Modify the SimpleCov.formatter assignment to be the following:

<syntaxhighlight lang="ruby">
SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
SimpleCov::Formatter::HTMLFormatter,
SimpleCov::Formatter::JSONFormatter
])
</syntaxhighlight>

3. Replace the <code>if !ENV['COVERAGE_STARTED']</code> block with the following:

<syntaxhighlight lang="ruby">
if !ENV['COVERAGE_STARTED']
SimpleCov.start 'rails' do
track_files 'app/models/{questionnaire,question_advice,course}.rb'
tracked = %w[
app/models/questionnaire.rb
app/models/question_advice.rb
app/models/course.rb
].map { |path| File.expand_path(path, SimpleCov.root) }

add_filter do |src|
!tracked.include?(src.filename)
end
end
ENV['COVERAGE_STARTED'] = 'true'
end
</syntaxhighlight>

== Results ==

=== Coverage ===

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

=== Bugs Fixed ===

==== Handling Nil User in add_ta Method (Course Model) ====
A bug was identified in the <code>Course</code> model where the <code>add_ta</code> method would crash when a <code>nil</code> user was passed during unit testing. The issue occurred because the method attempted to access <code>user.id</code> without first verifying that the user object was present.

To prevent this runtime error, the method was updated to safely handle <code>nil</code> inputs using safe navigation (<code>&.id</code>) and an early return pattern.

'''Fixed implementation:'''

<pre>
# Add a Teaching Assistant to the course
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user&.id} does not exist" }
elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }
else
# remaining logic...
end
end
</pre>

This fix ensures that the method no longer raises exceptions when a <code>nil</code> user is provided and instead returns a controlled error response, improving robustness and test reliability.

==== Corrected Course–User Association Mapping ====
A bug in the <code>Course</code> model was fixed where the <code>users</code> association incorrectly referenced a non-existent relationship (<code>course_participants</code>). The model already defines the correct join association as <code>participants</code>, so the additional reference caused confusion and potential runtime issues.

The association structure correctly uses <code>CourseParticipant</code> through <code>participants</code>, and <code>users</code> should be derived from this relationship.

'''Before fix:'''
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

'''Correct association structure:'''
<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :participants
</pre>

This fix ensures that the <code>users</code> association correctly resolves through the existing <code>participants</code> relationship, maintaining consistency in the model and preventing invalid association lookups.

==== Correct Foreign Key Mapping for QuestionAdvice Association ====
A fix was applied to the <code>QuestionAdvice</code> model to ensure the association correctly references the underlying database schema.

Previously, Rails was implicitly expecting a default foreign key (<code>item_id</code>), which did not match the actual schema. The <code>question_advice</code> table stores the foreign key as <code>question_id</code>, meaning the association must explicitly specify this key to function correctly.

To resolve this mismatch, the association was updated as follows:

<pre>
class QuestionAdvice < ApplicationRecord
belongs_to :item, foreign_key: :question_id
# remaining logic...
end
</pre>

This change ensures that Rails correctly maps each <code>QuestionAdvice</code> record to its associated <code>Item</code> using <code>question_id</code>, restoring proper association behavior and preventing incorrect lookups using the default key.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:49:15Z

Zobrook2: /* Running Tests */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

The following steps can be used to run only the tests relevant to this project.

In <code>spec_helper.rb</code>:

1. Add the following line to the require section:

<syntaxhighlight lang="ruby">
require 'simplecov-html'
</syntaxhighlight>

2. Modify the SimpleCov.formatter assignment to be the following:

<syntaxhighlight lang="ruby">
SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
SimpleCov::Formatter::HTMLFormatter,
SimpleCov::Formatter::JSONFormatter
])
</syntaxhighlight>

3. Replace the <code>if !ENV['COVERAGE_STARTED']</code> block with the following:

<syntaxhighlight lang="ruby">
if !ENV['COVERAGE_STARTED']
SimpleCov.start 'rails' do
track_files 'app/models/{questionnaire,question_advice,course}.rb'
tracked = %w[
app/models/questionnaire.rb
app/models/question_advice.rb
app/models/course.rb
].map { |path| File.expand_path(path, SimpleCov.root) }

add_filter do |src|
!tracked.include?(src.filename)
end
end
ENV['COVERAGE_STARTED'] = 'true'
end
</syntaxhighlight>

== Bugs Fixed ==

== Coverage and Results ==

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:42:08Z

Zobrook2: /* Coverage and Results */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

== Bugs Fixed ==

== Coverage and Results ==

Coverage results are shown in the table below:

{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/course.rb || 100.00% || 59 || 39 || 39 || 0 || 1.31
|-
| app/models/question_advice.rb || 100.00% || 24 || 13 || 13 || 0 || 1.54
|-
| app/models/questionnaire.rb || 100.00% || 141 || 64 || 64 || 0 || 6.36
|}

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:39:04Z

Zobrook2: /* Conclusion */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

== Bugs Fixed ==

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:38:02Z

Zobrook2: /* References */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

== Bugs Fixed ==

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:37:18Z

Zobrook2:

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Running Tests ==

== Bugs Fixed ==

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

== References ==

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:35:06Z

Zobrook2: /* Github */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Repository: [https://github.com/MATTMINWIN/reimplementation-back-end]

Link to Reimplementation Pull Request: [https://github.com/expertiza/reimplementation-back-end/pull/336]

== References ==

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:22:22Z

Zobrook2: /* Issues in Existing Code */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Initial Code ==

=== Bugs ===
The Course model contains inconsistent association naming. One declaration references the `participants` relationship, while another attempts to use `course_participants`, which is not defined. This mismatch can lead to runtime errors when accessing associated users.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===
The file <code>spec/models/questionnaire_spec.rb</code> provides test coverage primarily for validations, associations, and the <code>copy_questionnaire_details</code> method. However, multiple instance methods remain untested, and the <code>QuestionAdvice</code> model lacks sufficient coverage overall.

Similarly, <code>spec/models/course_spec.rb</code> focuses mainly on validations and the <code>path</code> method. Important instance methods such as <code>add_ta</code>, <code>remove_ta</code>, and <code>copy_course</code> are not covered by unit tests.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Project repo: [https://github.com/MATTMINWIN/reimplementation-back-end]

== References ==

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:20:04Z

Zobrook2: /* Method Description */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Descriptions ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Existing Code==

=== Bugs ===
The following statements in the Course model have inconsistent naming as the first statement relies on the relationship "participants" while the second statement relies on the relationship "course_participants" which doesn't exist.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===

spec/models/questionnaire_spec.rb exists but only covers validations, associations, and copy_questionnaire_details. Several instance methods and the entire QuestionAdvice model have less coverage.

spec/models/course_spec.rb only tests validations and the path method. Three instance methods - add_ta, remove_ta, and copy_course - have zero unit test coverage.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Project repo: [https://github.com/MATTMINWIN/reimplementation-back-end]

== References ==

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:19:20Z

Zobrook2: /* Method Description */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Description ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

1. validate_questionnaire
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

2. self.copy_questionnaire_details
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

3. check_for_question_associations
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

4. get_weighted_score
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

5. compute_weighted_score
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

6. true_false_items?
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

7. max_possible_score
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

1. self.export_fields
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

2. self.export
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

3. self.to_json_by_question_id
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

1. path
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

2. add_ta
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

3. remove_ta
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

4. copy_course
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Existing Code==

=== Bugs ===
The following statements in the Course model have inconsistent naming as the first statement relies on the relationship "participants" while the second statement relies on the relationship "course_participants" which doesn't exist.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===

spec/models/questionnaire_spec.rb exists but only covers validations, associations, and copy_questionnaire_details. Several instance methods and the entire QuestionAdvice model have less coverage.

spec/models/course_spec.rb only tests validations and the path method. Three instance methods - add_ta, remove_ta, and copy_course - have zero unit test coverage.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Project repo: [https://github.com/MATTMINWIN/reimplementation-back-end]

== References ==

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:16:43Z

Zobrook2: /* Test Methods */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Description ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

==== 1. validate_questionnaire ====
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

==== 2. self.copy_questionnaire_details ====
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

==== 3. check_for_question_associations ====
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

==== 4. get_weighted_score ====
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

==== 5. compute_weighted_score ====
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

==== 6. true_false_items? ====
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

==== 7. max_possible_score ====
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

==== 1. self.export_fields ====
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

==== 2. self.export ====
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

==== 3. self.to_json_by_question_id ====
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

==== 1. path ====
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

==== 2. add_ta ====
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

==== 3. remove_ta ====
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

==== 4. copy_course ====
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Existing Code==

=== Bugs ===
The following statements in the Course model have inconsistent naming as the first statement relies on the relationship "participants" while the second statement relies on the relationship "course_participants" which doesn't exist.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===

spec/models/questionnaire_spec.rb exists but only covers validations, associations, and copy_questionnaire_details. Several instance methods and the entire QuestionAdvice model have less coverage.

spec/models/course_spec.rb only tests validations and the path method. Three instance methods - add_ta, remove_ta, and copy_course - have zero unit test coverage.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods Overview ==

=== Questionnaire Model Test Setup ===
This suite provides a comprehensive setup for testing questionnaire behavior, including validation rules, scoring logic, duplication, and utility methods.

Key setup features:
* Stubbed User defaults
* Multiple questionnaire instances:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, max_question_score: 10) }
let(:questionnaire1) { build(:questionnaire, max_question_score: 20) }
let(:questionnaire2) { build(:questionnaire, max_question_score: 10) }
</syntaxhighlight>
* Associated questions with weights:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, weight: 1) }
let(:question2) { create(:item, weight: 10) }
</syntaxhighlight>
* Mocked dependencies:
* AssignmentQuestionnaire for scoring logic
* Participant/review objects using doubles

This setup supports testing:
* Field validations (name, min/max scores)
* Associations with items
* Deep copy functionality (including nested advice records)
* Scoring algorithms and weighted calculations
* Serialization and helper methods

The structure ensures isolation of logic while simulating realistic relationships between models.

=== Questionnaire Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice Model Test Setup ===
This suite focuses on relationships between questionnaires, questions (items), and advice entries. It builds a structured dataset with multiple linked records.

Key setup features:
* Stubbed User defaults
* Questionnaire with scoring bounds:
<syntaxhighlight lang="ruby">
let(:questionnaire) { create(:questionnaire, min_question_score: 0, max_question_score: 10) }
</syntaxhighlight>
* Associated questions:
<syntaxhighlight lang="ruby">
let(:question1) { create(:item, questionnaire: questionnaire) }
let(:question2) { create(:item, questionnaire: questionnaire) }
</syntaxhighlight>
* QuestionAdvice entries:
* Default values (implicit score/advice)
* Custom values for testing overrides

This setup enables validation of:
* Default attribute values
* Associations
* Export functionality
* JSON formatting methods

=== QuestionAdvice Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course Model Test Setup ===
The Course test suite establishes core domain objects using factories, including an instructor, institution, and course. User callbacks are stubbed to avoid unintended initialization side effects.

Key setup features:
* Stubbed User defaults:
<syntaxhighlight lang="ruby">
allow_any_instance_of(User).to receive(:set_defaults)
</syntaxhighlight>
* Core entities:
<syntaxhighlight lang="ruby">
let(:instructor) { create(:instructor) }
let(:institution) { create(:institution) }
let(:course) { create(:course, instructor: instructor, institution: institution) }
</syntaxhighlight>
* Additional supporting objects:
* Users with roles (student, TA, instructor)
* CourseParticipant and TaMapping records

This setup supports testing validations, associations, and course management methods such as TA assignment and course duplication.

=== Course Model Test Methods ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Project repo: [https://github.com/MATTMINWIN/reimplementation-back-end]

== References ==

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:08:01Z

Zobrook2: /* Test Methods */

== Project Description ==

This project is oriented around the testing of three models representing the individual reviews that each student will be conducting for an assignment. The Questionnaire model represents a review rubric used in assignments. It holds a set of scored questions with configurable min/max score bounds, belongs to an instructor, and supports being copied (along with all its questions and advice) for reuse. It also provides scoring utilities used during assignment evaluation. The QuestionAdvice model represents the score-specific feedback hints attached to a question in a questionnaire (e.g., "if you give a score of 3, here's what that means"). It provides class-level methods to export advice records to CSV and to fetch advice for a given question as JSON. The Course model represents a course in the system. It manages the course's filesystem submission path, handles adding and removing Teaching Assistants (updating their role accordingly via TaMapping), and supports duplicating a course via copy_course. The emphasis is on making sure that the methods associated with the model classes for Questionnaires, QuestionAdvice, and Course are tested using RSpec unit testing and resolving any bugs that are present in the current implementation.

{| class="wikitable"; margin-left:20px; width:320px;"
|-
! colspan="2" style="background:#cee0f2; text-align:center;" | Project Info
|-
| '''Course''' || CSC/ECE 517 Spring 2026
|-
| '''Project''' || E2617 — Testing Questionnaire and Course Models
|-
| '''Instructor''' || Ed Gehringer
|-
| '''Mentor''' || Aanand Sreekumaran Nair Jayakumari
|-
| '''Collaborators''' || DJ Hansen, Zack Brooks, Matt Nguyen
|-
| '''Platform''' || Expertiza (Ruby on Rails)
|-
| '''Test Framework''' || RSpec
|-
| '''Root Class''' || <code>ApplicationRecord</code> (STI superclass)
|-
| '''Subclasses''' || <code>Questionnaire</code>, <code>QuestionAdvice</code>, <code>Course</code>
|-

|}

==Model Documentation==

Questionnaire Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Questionnaires]

QuestionAdvice Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Question_advices]

Course Model: [https://wiki.expertiza.ncsu.edu/index.php?title=Courses_table]

== Method Description ==
The next section outlines the existing implementation of the methods to be unit tested.

=== Questionnaire Model Methods ===

==== 1. validate_questionnaire ====
Validates a questionnaire by ensuring:
* Maximum score is a positive integer
* Minimum score is a non-negative integer
* Minimum score is less than the maximum score
* Questionnaire name is unique per instructor

<pre>
def validate_questionnaire
errors.add(:max_question_score, 'The maximum item score must be a positive integer.') if max_question_score < 1
errors.add(:min_question_score, 'The minimum item score must be a positive integer.') if min_question_score < 0
errors.add(:min_question_score, 'The minimum item score must be less than the maximum.') if min_question_score >= max_question_score
results = Questionnaire.where('id <> ? and name = ? and instructor_id = ?', id, name, instructor_id)
errors.add(:name, 'Questionnaire names must be unique.') if results.present?
end
</pre>

==== 2. self.copy_questionnaire_details ====
Clones a questionnaire, including its items and associated advice.

<pre>
def self.copy_questionnaire_details(params)
orig_questionnaire = Questionnaire.find(params[:id])
items = Item.where(questionnaire_id: params[:id])
questionnaire = orig_questionnaire.dup
questionnaire.instructor_id = params[:instructor_id]
questionnaire.name = 'Copy of ' + orig_questionnaire.name
questionnaire.created_at = Time.zone.now
questionnaire.save!

items.each do |question|
new_question = question.dup
new_question.questionnaire_id = questionnaire.id
new_question.size = '50,3' if (new_question.is_a?(Criterion) || new_question.is_a?(TextResponse)) && new_question.size.nil?
new_question.save!

advice = QuestionAdvice.where(question_id: question.id)
next if advice.empty?

advice.each do |advice|
new_advice = advice.dup
new_advice.question_id = new_question.id
new_advice.save!
end
end

questionnaire
end
</pre>

==== 3. check_for_question_associations ====
Checks whether the questionnaire has associated items before deletion.

<pre>
def check_for_question_associations
if items.any?
raise ActiveRecord::DeleteRestrictionError.new("Cannot delete record because dependent items exist")
end
end
</pre>

==== 4. get_weighted_score ====
Calculates the weighted score by generating a symbol and calling a helper method.

<pre>
def get_weighted_score(assignment, scores)
# create symbol for "varying rubrics" feature -Yang
round = AssignmentQuestionnaire.find_by(assignment_id: assignment.id, questionnaire_id: id).used_in_round

questionnaire_symbol = if round.nil?
symbol
else
(symbol.to_s + round.to_s).to_sym
end

compute_weighted_score(questionnaire_symbol, assignment, scores)
end
</pre>

==== 5. compute_weighted_score ====
Helper method that computes the weighted score for an assignment.

<pre>
def compute_weighted_score(symbol, assignment, scores)
aq = AssignmentQuestionnaire.find_by(assignment_id: assignment.id)

if scores[symbol][:scores][:avg].nil?
0
else
scores[symbol][:scores][:avg] * aq.questionnaire_weight / 100.0
end
end
</pre>

==== 6. true_false_items? ====
Checks if the questionnaire contains any true/false (checkbox) items.

<pre>
def true_false_items?
items.each { |question| return true if question.type == 'Checkbox' }
false
end
</pre>

==== 7. max_possible_score ====
Calculates the maximum possible score based on item weights and max question score.

<pre>
def max_possible_score
results = Questionnaire.joins('INNER JOIN items ON items.questionnaire_id = questionnaires.id')
.select('SUM(items.weight) * questionnaires.max_question_score as max_score')
.where('questionnaires.id = ?', id)
results[0].max_score
end
</pre>

=== QuestionAdvice Model Methods ===

==== 1. self.export_fields ====
Returns all column names of QuestionAdvice as strings.

<pre>
def self.export_fields(_options)
QuestionAdvice.columns.map(&:name)
end
</pre>

==== 2. self.export ====
Exports QuestionAdvice entries to a CSV file.

<pre>
def self.export(csv, parent_id, _options)
questionnaire = Questionnaire.find(parent_id)

questionnaire.items.each do |item|
QuestionAdvice.where(question_id: item.id).each do |advice|
csv << advice.attributes.values
end
end
end
</pre>

==== 3. self.to_json_by_question_id ====
Exports QuestionAdvice entries to JSON format by question ID.

<pre>
def self.to_json_by_question_id(question_id)
question_advices = QuestionAdvice.where(question_id: question_id).order(:id)

question_advices.map do |advice|
{ score: advice.score, advice: advice.advice }
end
end
</pre>

=== Course Model Methods ===

==== 1. path ====
Returns the submission directory path for the course.

<pre>
def path
raise 'Path can not be created as the course must be associated with an instructor.' if instructor_id.nil?

Rails.root + '/' +
Institution.find(institution_id).name.gsub(" ", "") + '/' +
User.find(instructor_id).name.gsub(" ", "") + '/' +
directory_path + '/'
end
</pre>

==== 2. add_ta ====
Adds a Teaching Assistant (TA) to the course.

<pre>
def add_ta(user)
if user.nil?
return { success: false, message: "The user with id #{user.id} does not exist" }

elsif TaMapping.exists?(user_id: user.id, course_id: id)
return { success: false, message: "The user with id #{user.id} is already a TA for this course." }

else
ta_mapping = TaMapping.create(user_id: user.id, course_id: id)
ta_role = Role.find_by(name: 'Teaching Assistant')
user.update(role: ta_role) if ta_role

if ta_mapping.save
return { success: true, data: ta_mapping.slice(:course_id, :user_id) }
else
return { success: false, message: ta_mapping.errors }
end
end
end
</pre>

==== 3. remove_ta ====
Removes a Teaching Assistant from the course.

<pre>
def remove_ta(user_id)
ta_mapping = ta_mappings.find_by(user_id: user_id, course_id: :id)
return { success: false, message: "No TA mapping found for the specified course and TA" } if ta_mapping.nil?

ta = User.find(ta_mapping.user_id)
ta_count = TaMapping.where(user_id: user_id).size - 1

if ta_count.zero?
ta.update(role: Role::STUDENT)
end

ta_mapping.destroy
{ success: true, ta_name: ta.name }
end
</pre>

==== 4. copy_course ====
Creates a duplicate of the course.

<pre>
def copy_course
new_course = dup
new_course.directory_path += '_copy'
new_course.name += '_copy'
new_course.save
end
</pre>

== Issues in Existing Code==

=== Bugs ===
The following statements in the Course model have inconsistent naming as the first statement relies on the relationship "participants" while the second statement relies on the relationship "course_participants" which doesn't exist.

<pre>
has_many :participants, class_name: 'CourseParticipant', foreign_key: 'parent_id', dependent: :destroy, inverse_of: :course
has_many :users, through: :course_participants, inverse_of: :course
</pre>

=== Coverage Issues ===

spec/models/questionnaire_spec.rb exists but only covers validations, associations, and copy_questionnaire_details. Several instance methods and the entire QuestionAdvice model have less coverage.

spec/models/course_spec.rb only tests validations and the path method. Three instance methods - add_ta, remove_ta, and copy_course - have zero unit test coverage.

== Test Plan ==

For this project, we will be using factories and fixtures to generate our models for unit testing with RSpec.

==== Questionnaire ====

Currently for Questionnaire, the data for unit testing is currently being created using Factory so we will continue to write tests that ensure over 80% code coverage. We will also use factories for the Course model as the method logic is dependent on varying data. It allows us to adjust parameters and test for edge cases easier.

The following code is currently how the factory for the Questionnaire model is set up.

<pre>
# spec/factories/questionnaires.rb
FactoryBot.define do
factory :questionnaire do
sequence(:name) { |n| "Questionnaire #{n}" }
private { false }
min_question_score { 0 }
max_question_score { 10 }
association :instructor
association :assignment

# Trait for questionnaire with questions
trait :with_questions do
after(:create) do |questionnaire|
create(:item, questionnaire: questionnaire, weight: 1, seq: 1, txt: "que 1", question_type: "Scale")
create(:item, questionnaire: questionnaire, weight: 10, seq: 2, txt: "que 2", question_type: "Checkbox")
end
end
end
end
</pre>

The following code serves as the factory for generating instances of items which are essentially questions in a questionnaire object.

<pre>
# spec/factories/items.rb
FactoryBot.define do
factory :item do
sequence(:txt) { |n| "Question #{n}" }
sequence(:seq) { |n| n }
weight { 1 }
question_type { "Scale" }
break_before { true }
association :questionnaire
end
end
</pre>

==== Course ====

The following code is the current version of the factory for the course models.

<pre>
FactoryBot.define do
factory :course do
name { Faker::Educator.course_name }
info { Faker::Lorem.paragraph }
private { false }
directory_path { Faker::File.dir }
association :institution, factory: :institution
association :instructor, factory: :user
end
end
</pre>

==== QuestionAdvice ====

For QuestionAdvice use fixtures to load data into database to test that it is being saved and exported properly. As it stands, there isn't that much logical complexity with the data inside QuestionAdvice itself as it is more concerned with exporting data into csv or json files for storage. The fixtures are stored in question_advice.yml under the fixtures folder.

<pre>
#question_advice.yml

question_advice_1:
id: 1
question_id: 1
score: 5
advice: "This is some advice for question 1."

question_advice_2:
id: 2
question_id: 2
score: 3
advice: "This is some advice for question 2."
</pre>

== Test Methods ==

=== Questionnaire ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| name returns correct values
| Verifies that questionnaire names are correctly assigned and retrieved.
| <syntaxhighlight lang="ruby">
expect(questionnaire.name).to eq('abc')
expect(questionnaire1.name).to eq('xyz')
expect(questionnaire2.name).to eq('pqr')
</syntaxhighlight>
|-
| name presence validation
| Ensures the questionnaire name cannot be blank.
| <syntaxhighlight lang="ruby">
questionnaire.name = ' '
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| instructor_id retrieval
| Confirms the questionnaire returns the correct instructor ID.
| <syntaxhighlight lang="ruby">
expect(questionnaire.instructor_id).to eq(instructor.id)
</syntaxhighlight>
|-
| maximum_score validation (type and positivity)
| Validates max score is an integer, positive, and greater than minimum score.
| <syntaxhighlight lang="ruby">
expect(questionnaire.max_question_score).to eq(10)

questionnaire.max_question_score = 'a'
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = -10
expect(questionnaire).not_to be_valid

questionnaire.max_question_score = 0
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 1
expect(questionnaire).to be_valid
</syntaxhighlight>
|-
| minimum_score validation
| Ensures minimum score is valid, integer, and less than maximum score.
| <syntaxhighlight lang="ruby">
questionnaire.min_question_score = 5
expect(questionnaire.min_question_score).to eq(5)

questionnaire.min_question_score = 10
expect(questionnaire).not_to be_valid

questionnaire.min_question_score = 'a'
expect(questionnaire).not_to be_valid
</syntaxhighlight>
|-
| association with items
| Verifies that a questionnaire has many associated questions.
| <syntaxhighlight lang="ruby">
question1
question2
expect(questionnaire.items.reload).to include(question1, question2)
</syntaxhighlight>
|-
| copy_questionnaire_details creates copy
| Ensures a questionnaire copy is created with correct attributes.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
Questionnaire.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.instructor_id)
.to eq(questionnaire.instructor_id)

expect(copied_questionnaire.name)
.to eq("Copy of #{questionnaire.name}")

expect(copied_questionnaire.created_at)
.to be_within(1.second).of(Time.zone.now)
</syntaxhighlight>
|-
| copy_questionnaire_details copies items
| Verifies all questions are duplicated in the copied questionnaire.
| <syntaxhighlight lang="ruby">
question1
question2

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

expect(copied_questionnaire.items.count).to eq(2)
expect(copied_questionnaire.items.first.txt).to eq(question1.txt)
expect(copied_questionnaire.items.second.txt).to eq(question2.txt)
</syntaxhighlight>
|-
| copy_questionnaire_details copies advice
| Ensures associated advice records are duplicated with questions.
| <syntaxhighlight lang="ruby">
question1

QuestionAdvice.insert(
{
question_id: question1.id,
score: 3,
advice: 'Good rationale',
created_at: Time.zone.now,
updated_at: Time.zone.now
}
)

copied_questionnaire =
described_class.copy_questionnaire_details(
{ id: questionnaire.id, instructor_id: instructor.id }
)

copied_question = copied_questionnaire.items.first
copied_advice = QuestionAdvice.where(question_id: copied_question.id)

expect(copied_advice.count).to eq(1)
expect(copied_advice.first.score).to eq(3)
expect(copied_advice.first.advice).to eq('Good rationale')
</syntaxhighlight>
|-
| symbol method
| Confirms the questionnaire returns the correct symbol.
| <syntaxhighlight lang="ruby">
expect(questionnaire.symbol).to eq(:review)
</syntaxhighlight>
|-
| get_assessments_for
| Verifies retrieval of participant reviews.
| <syntaxhighlight lang="ruby">
reviews = [double('review1'), double('review2')]
participant = double('participant', reviews: reviews)

expect(questionnaire.get_assessments_for(participant)).to eq(reviews)
</syntaxhighlight>
|-
| check_for_question_associations restriction
| Prevents deletion when associated questions exist and allows otherwise.
| <syntaxhighlight lang="ruby">
question1
questionnaire.items.reload

expect {
questionnaire.check_for_question_associations
}.to raise_error(ActiveRecord::DeleteRestrictionError)

questionnaire_without_items = build(:questionnaire)

expect {
questionnaire_without_items.check_for_question_associations
}.not_to raise_error
</syntaxhighlight>
|-
| as_json serialization
| Ensures JSON output includes required fields.
| <syntaxhighlight lang="ruby">
json = questionnaire.as_json
expect(json).to include('id', 'name', 'instructor')
</syntaxhighlight>
|-
| get_weighted_score behavior
| Uses appropriate symbol depending on round configuration.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 42)

aq = double('assignment_questionnaire', used_in_round: nil)
allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 42, questionnaire_id: questionnaire.id)
.and_return(aq)

expect(questionnaire).to receive(:compute_weighted_score)
.with(:review, assignment, {})

questionnaire.get_weighted_score(assignment, {})
</syntaxhighlight>
|-
| compute_weighted_score
| Calculates weighted score or returns zero if no average exists.
| <syntaxhighlight lang="ruby">
assignment = double('assignment', id: 77)

allow(AssignmentQuestionnaire).to receive(:find_by)
.with(assignment_id: 77)
.and_return(double('aq', questionnaire_weight: 25))

scores = { review: { scores: { avg: nil } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(0)

scores = { review: { scores: { avg: 8 } } }
expect(questionnaire.compute_weighted_score(:review, assignment, scores)).to eq(2.0)
</syntaxhighlight>
|-
| true_false_items?
| Detects presence or absence of checkbox-type questions.
| <syntaxhighlight lang="ruby">
allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Checkbox')])
expect(questionnaire.true_false_items?).to be(true)

allow(questionnaire).to receive(:items)
.and_return([double('item', type: 'Criterion')])
expect(questionnaire.true_false_items?).to be(false)
</syntaxhighlight>
|-
| max_possible_score
| Computes total possible score based on weights and max score.
| <syntaxhighlight lang="ruby">
question1
question2

# question1.weight = 1, question2.weight = 10
# max_question_score = 10

expect(questionnaire.max_possible_score.to_i).to eq(110)
</syntaxhighlight>
|}

=== QuestionAdvice ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| question association returns correct question_id
| Verifies that each QuestionAdvice correctly references its associated question.
| <syntaxhighlight lang="ruby">
expect(question_advice1.question_id).to eq(question1.id)
expect(question_advice2.question_id).to eq(question2.id)
</syntaxhighlight>
|-
| score returns correct value
| Ensures that the score attribute of QuestionAdvice is returned correctly, including defaults.
| <syntaxhighlight lang="ruby">
expect(question_advice1.score).to eq(5)
expect(question_advice2.score).to eq(6)
</syntaxhighlight>
|-
| advice returns correct value
| Ensures that the advice attribute is returned correctly, including default advice text.
| <syntaxhighlight lang="ruby">
expect(question_advice1.advice).to eq('default advice')
expect(question_advice2.advice).to eq('advice for question 2')
</syntaxhighlight>
|-
| export_fields mapping
| Verifies that export_fields returns the correct column mappings.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.export_fields({})
expect(output).to eq(["id", "question_id", "score", "advice", "created_at", "updated_at"])
</syntaxhighlight>
|-
| export method stores values
| Tests that the export method correctly appends QuestionAdvice records to a CSV array.
| <syntaxhighlight lang="ruby">
csv = []
QuestionAdvice.export(csv, questionnaire.id, nil)
expect(csv.length).to eq(3)
</syntaxhighlight>
|-
| to_json_by_question_id for question1
| Verifies JSON output for all QuestionAdvice entries associated with question 1.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question1.id)
expect(output).to eq([
{ score: 5, advice: 'default advice' },
{ score: 1, advice: 'advice for question 3' }
])
</syntaxhighlight>
|-
| to_json_by_question_id for question2
| Verifies JSON output for QuestionAdvice entries associated with question 2.
| <syntaxhighlight lang="ruby">
output = QuestionAdvice.to_json_by_question_id(question2.id)
expect(output).to eq([
{ score: 6, advice: 'advice for question 2'}
])
</syntaxhighlight>
|}

=== Course ===

{| class="wikitable"
! Test Method !! Description !! Code Snippet
|-
| validates presence of name
| Ensures that a course must have a name to be valid.
| <syntaxhighlight lang="ruby">
course.name = ''
expect(course).not_to be_valid
</syntaxhighlight>
|-
| validates presence of directory_path
| Ensures that a course must have a directory path to be valid.
| <syntaxhighlight lang="ruby">
course.directory_path = ' '
expect(course).not_to be_valid
</syntaxhighlight>
|-
| returns users through participants
| Verifies that users associated through course participants are accessible.
| <syntaxhighlight lang="ruby">
student = create(:user, :student)
create(:course_participant, course: course, user: student)
expect(course.users).to include(student)
</syntaxhighlight>
|-
| path raises error without instructor
| Ensures an error is raised when generating a path without an associated instructor.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(nil)
expect { course.path }.to raise_error
</syntaxhighlight>
|-
| path returns directory with instructor
| Verifies a directory path is returned when instructor and institution exist.
| <syntaxhighlight lang="ruby">
allow(course).to receive(:instructor_id).and_return(6)
allow(User).to receive(:find).with(6).and_return(user1)
expect(course.path.directory?).to be_truthy
</syntaxhighlight>
|-
| add_ta success
| Adds a TA and updates the user role accordingly.
| <syntaxhighlight lang="ruby">
result = course.add_ta(ta_user)
expect(result[:success]).to be(true)
expect(result[:data]).to include('course_id' => course.id, 'user_id' => ta_user.id)
expect(ta_user.reload.role.name).to eq('Teaching Assistant')
</syntaxhighlight>
|-
| add_ta already exists
| Prevents adding a TA who is already assigned to the course.
| <syntaxhighlight lang="ruby">
TaMapping.create!(user_id: ta_user.id, course_id: course.id)
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta nil user
| Returns an error when attempting to add a non-existent user.
| <syntaxhighlight lang="ruby">
result = course.add_ta(nil)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| add_ta save failure
| Returns validation errors when TA mapping fails to save.
| <syntaxhighlight lang="ruby">
allow(TaMapping).to receive(:create).and_return(double(save: false))
result = course.add_ta(ta_user)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta no mapping
| Returns an error when no TA mapping exists.
| <syntaxhighlight lang="ruby">
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(false)
</syntaxhighlight>
|-
| remove_ta success
| Removes a TA mapping and updates role if it was the last assignment.
| <syntaxhighlight lang="ruby">
ta_mapping = TaMapping.create!(user_id: ta_user.id, course_id: course.id)
allow(course.ta_mappings).to receive(:find_by).and_return(ta_mapping)
allow(TaMapping).to receive(:where).with(user_id: ta_user.id).and_return([ta_mapping])
stub_const('Role::STUDENT', student_role)
result = course.remove_ta(ta_user.id)
expect(result[:success]).to be(true)
</syntaxhighlight>
|-
| copy_course success
| Creates a duplicate course with modified name and directory path.
| <syntaxhighlight lang="ruby">
result = course.copy_course
expect(result).to be(true)
</syntaxhighlight>
|}

== Coverage and Results ==

Test Results:
{| class="wikitable"
! File !! % covered !! Lines !! Relevant Lines !! Lines covered !! Lines missed !! Avg. Hits / Line
|-
| app/models/questionnaire.rb || 64.06% || 141 || 64 || 41 || 23 || 3.02
|-
| app/models/question_advice.rb || 38.46% || 24 || 13 || 5 || 8 || 0.38
|-
| app/models/course.rb || 43.59% || 59 || 39 || 17 || 22 || 0.46
|}

== Conclusion ==
This section will be updated with final results at the end of the project.

== Github ==
Link to Github Project repo: [https://github.com/MATTMINWIN/reimplementation-back-end]

== References ==

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T05:04:01Z

Zobrook2: /* QuestionAdvice */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-24T04:58:10Z

Zobrook2:

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:48:55Z

Zobrook2: /* Key Relationships */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:47:53Z

Zobrook2: /* Key Relationships */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:47:33Z

Zobrook2: /* Key Relationships */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:47:10Z

Zobrook2: /* Project Description */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:37:39Z

Zobrook2: /* Test Plan */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:34:01Z

Zobrook2: /* Project Description */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:32:12Z

Zobrook2: /* Coverage */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:30:58Z

Zobrook2: /* Project Description */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:25:14Z

Zobrook2: /* Method Description */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:21:24Z

Zobrook2: /* Course Model */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:19:42Z

Zobrook2: /* Key Relationships: */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:19:21Z

Zobrook2: /* Key Relationships: */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:19:15Z

Zobrook2: /* QuestionAdvice Model */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:18:55Z

Zobrook2: /* Questionnaire Model */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:18:39Z

Zobrook2: /* Questionnaire Model */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:13:57Z

Zobrook2: /* Questionnaire Model */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:12:27Z

Zobrook2: /* Conclusion */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-14T00:00:05Z

Zobrook2: /* Github */

CSC/ECE 517 Spring 2026 - E2617. Testing Questionnaire and Course Models

2026-04-13T23:48:43Z

Zobrook2: /* Project Description */

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-04-03T20:23:37Z

Zobrook2: /* Dynamic Strategy Configuration */

= Review Strategy Tab: Frontend Documentation =

This page documents the functional behavior and UI logic for the '''Review Strategy''' tab. The interface manages how reviewers are assigned to submissions, incorporating conditional logic based on global settings defined in the "General" tab (e.g., Calibration, Topics, and Teams).

== Overview ==
The Review Strategy interface allows instructors to toggle between manual and automated assignment models. This version renames legacy strategies to improve clarity and introduces dynamic field visibility based on the system state.

== Primary Strategy Selection ==
The instructor initiates configuration via the '''Review strategy''' dropdown:
* '''Static''' (formerly "Instructor-Selected"): Used for manual or rule-based distributions.
* '''Dynamic''' (formerly "Auto-Selected"): Used for algorithmic, real-time distributions.

== Static Strategy Configuration ==
When '''Static''' is selected, the following interface elements are exposed:

[[File:static page.png|right|thumb|600px|Reimplementation of static assignment page]]

=== Assignment Methods ===
Instructors select from three methods under the prompt: ''"How should reviewers be assigned?"''

# '''Round robin:''' Includes an info tooltip explaining sequential distribution.
# '''Random:''' Assignments are distributed randomly.
# '''Import File:'''
#* '''UI Logic:''' Selecting this option reveals an '''Import Button'''.
#* '''Visibility:''' The "Number of reviews" and "Pre-submission" fields are hidden when this method is active.

=== Review Counts & Logic ===
Field labels and visibility depend on the '''Calibration for training''' setting in the General tab:

* '''Standard Label:''' "Number of reviews each reviewer is required to do."
* '''Calibration Label:''' If Calibration is enabled, the label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and a new field, '''"Number of calibrated reviews"''', becomes visible.
* '''Pre-submission Assignments:''' A checkbox labeled "Assign reviewers to review projects that have not yet been submitted" (Defaults to '''Checked''').

=== Execution ===
* '''Assign Reviewers Button:''' Visible only when required parameters are defined. Clicking this triggers the backend mapping logic.

== Dynamic Strategy Configuration ==
When '''Dynamic''' is selected, the following configuration fields are exposed:

[[File:dynamic page.png|right|thumb|600px|Reimplementation of dynamic assignment page]]

* '''Number of reviews each reviewer is required to do:''' Integer input field.
* '''Max. number of reviews each reviewer is allowed to do:''' This field is automatically pre-populated with the value entered in the "required" field.
* '''Review topic threshold (k):'''
** '''Visibility:''' Only appears if '''Has topics?''' is enabled on the General tab.
** '''Default:''' Pre-populated with '''1'''.
** '''Tooltip:''' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
These settings are persistent across both Static and Dynamic strategies, though some are subject to conditional visibility.

{| class="wikitable"
! Field !! Visibility !! Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see the identity of their reviewers.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to assigned peers.
|-
| '''Is reviewing role-based?''' || Only if '''Has teams?''' is checked || Each team member selects a role and reviews based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Only if '''Has teams?''' is checked || Assignment logic treats the team as a single unit rather than individuals.
|}

== Technical Implementation ==
The frontend captures the current state of all visible fields and transmits the configuration to the backend API. This ensures the specific assignment parameters and conditional logic states are correctly persisted in the database.

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-04-03T20:23:28Z

Zobrook2: /* Dynamic Strategy Configuration */

= Review Strategy Tab: Frontend Documentation =

This page documents the functional behavior and UI logic for the '''Review Strategy''' tab. The interface manages how reviewers are assigned to submissions, incorporating conditional logic based on global settings defined in the "General" tab (e.g., Calibration, Topics, and Teams).

== Overview ==
The Review Strategy interface allows instructors to toggle between manual and automated assignment models. This version renames legacy strategies to improve clarity and introduces dynamic field visibility based on the system state.

== Primary Strategy Selection ==
The instructor initiates configuration via the '''Review strategy''' dropdown:
* '''Static''' (formerly "Instructor-Selected"): Used for manual or rule-based distributions.
* '''Dynamic''' (formerly "Auto-Selected"): Used for algorithmic, real-time distributions.

== Static Strategy Configuration ==
When '''Static''' is selected, the following interface elements are exposed:

[[File:static page.png|right|thumb|600px|Reimplementation of static assignment page]]

=== Assignment Methods ===
Instructors select from three methods under the prompt: ''"How should reviewers be assigned?"''

# '''Round robin:''' Includes an info tooltip explaining sequential distribution.
# '''Random:''' Assignments are distributed randomly.
# '''Import File:'''
#* '''UI Logic:''' Selecting this option reveals an '''Import Button'''.
#* '''Visibility:''' The "Number of reviews" and "Pre-submission" fields are hidden when this method is active.

=== Review Counts & Logic ===
Field labels and visibility depend on the '''Calibration for training''' setting in the General tab:

* '''Standard Label:''' "Number of reviews each reviewer is required to do."
* '''Calibration Label:''' If Calibration is enabled, the label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and a new field, '''"Number of calibrated reviews"''', becomes visible.
* '''Pre-submission Assignments:''' A checkbox labeled "Assign reviewers to review projects that have not yet been submitted" (Defaults to '''Checked''').

=== Execution ===
* '''Assign Reviewers Button:''' Visible only when required parameters are defined. Clicking this triggers the backend mapping logic.

== Dynamic Strategy Configuration ==
When '''Dynamic''' is selected, the following configuration fields are exposed:

[[File:dynamic page.png|right|thumb|700px|Reimplementation of dynamic assignment page]]

* '''Number of reviews each reviewer is required to do:''' Integer input field.
* '''Max. number of reviews each reviewer is allowed to do:''' This field is automatically pre-populated with the value entered in the "required" field.
* '''Review topic threshold (k):'''
** '''Visibility:''' Only appears if '''Has topics?''' is enabled on the General tab.
** '''Default:''' Pre-populated with '''1'''.
** '''Tooltip:''' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
These settings are persistent across both Static and Dynamic strategies, though some are subject to conditional visibility.

{| class="wikitable"
! Field !! Visibility !! Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see the identity of their reviewers.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to assigned peers.
|-
| '''Is reviewing role-based?''' || Only if '''Has teams?''' is checked || Each team member selects a role and reviews based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Only if '''Has teams?''' is checked || Assignment logic treats the team as a single unit rather than individuals.
|}

== Technical Implementation ==
The frontend captures the current state of all visible fields and transmits the configuration to the backend API. This ensures the specific assignment parameters and conditional logic states are correctly persisted in the database.

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-04-03T20:23:17Z

Zobrook2: /* Dynamic Strategy Configuration */

= Review Strategy Tab: Frontend Documentation =

This page documents the functional behavior and UI logic for the '''Review Strategy''' tab. The interface manages how reviewers are assigned to submissions, incorporating conditional logic based on global settings defined in the "General" tab (e.g., Calibration, Topics, and Teams).

== Overview ==
The Review Strategy interface allows instructors to toggle between manual and automated assignment models. This version renames legacy strategies to improve clarity and introduces dynamic field visibility based on the system state.

== Primary Strategy Selection ==
The instructor initiates configuration via the '''Review strategy''' dropdown:
* '''Static''' (formerly "Instructor-Selected"): Used for manual or rule-based distributions.
* '''Dynamic''' (formerly "Auto-Selected"): Used for algorithmic, real-time distributions.

== Static Strategy Configuration ==
When '''Static''' is selected, the following interface elements are exposed:

[[File:static page.png|right|thumb|600px|Reimplementation of static assignment page]]

=== Assignment Methods ===
Instructors select from three methods under the prompt: ''"How should reviewers be assigned?"''

# '''Round robin:''' Includes an info tooltip explaining sequential distribution.
# '''Random:''' Assignments are distributed randomly.
# '''Import File:'''
#* '''UI Logic:''' Selecting this option reveals an '''Import Button'''.
#* '''Visibility:''' The "Number of reviews" and "Pre-submission" fields are hidden when this method is active.

=== Review Counts & Logic ===
Field labels and visibility depend on the '''Calibration for training''' setting in the General tab:

* '''Standard Label:''' "Number of reviews each reviewer is required to do."
* '''Calibration Label:''' If Calibration is enabled, the label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and a new field, '''"Number of calibrated reviews"''', becomes visible.
* '''Pre-submission Assignments:''' A checkbox labeled "Assign reviewers to review projects that have not yet been submitted" (Defaults to '''Checked''').

=== Execution ===
* '''Assign Reviewers Button:''' Visible only when required parameters are defined. Clicking this triggers the backend mapping logic.

== Dynamic Strategy Configuration ==
When '''Dynamic''' is selected, the following configuration fields are exposed:

[[File:dynamic page.png|right|thumb|550px|Reimplementation of dynamic assignment page]]

* '''Number of reviews each reviewer is required to do:''' Integer input field.
* '''Max. number of reviews each reviewer is allowed to do:''' This field is automatically pre-populated with the value entered in the "required" field.
* '''Review topic threshold (k):'''
** '''Visibility:''' Only appears if '''Has topics?''' is enabled on the General tab.
** '''Default:''' Pre-populated with '''1'''.
** '''Tooltip:''' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
These settings are persistent across both Static and Dynamic strategies, though some are subject to conditional visibility.

{| class="wikitable"
! Field !! Visibility !! Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see the identity of their reviewers.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to assigned peers.
|-
| '''Is reviewing role-based?''' || Only if '''Has teams?''' is checked || Each team member selects a role and reviews based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Only if '''Has teams?''' is checked || Assignment logic treats the team as a single unit rather than individuals.
|}

== Technical Implementation ==
The frontend captures the current state of all visible fields and transmits the configuration to the backend API. This ensures the specific assignment parameters and conditional logic states are correctly persisted in the database.

File:Dynamic page.png

2026-04-03T20:22:45Z

Zobrook2:

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-04-03T20:22:30Z

Zobrook2: /* Dynamic Strategy Configuration */

File:Static page.png

2026-04-03T20:21:20Z

Zobrook2:

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-04-03T20:20:57Z

Zobrook2: /* Static Strategy Configuration */

= Review Strategy Tab: Frontend Documentation =

This page documents the functional behavior and UI logic for the '''Review Strategy''' tab. The interface manages how reviewers are assigned to submissions, incorporating conditional logic based on global settings defined in the "General" tab (e.g., Calibration, Topics, and Teams).

== Overview ==
The Review Strategy interface allows instructors to toggle between manual and automated assignment models. This version renames legacy strategies to improve clarity and introduces dynamic field visibility based on the system state.

== Primary Strategy Selection ==
The instructor initiates configuration via the '''Review strategy''' dropdown:
* '''Static''' (formerly "Instructor-Selected"): Used for manual or rule-based distributions.
* '''Dynamic''' (formerly "Auto-Selected"): Used for algorithmic, real-time distributions.

== Static Strategy Configuration ==
When '''Static''' is selected, the following interface elements are exposed:

[[File:static page.png|right|thumb|600px|Reimplementation of static assignment page]]

=== Assignment Methods ===
Instructors select from three methods under the prompt: ''"How should reviewers be assigned?"''

# '''Round robin:''' Includes an info tooltip explaining sequential distribution.
# '''Random:''' Assignments are distributed randomly.
# '''Import File:'''
#* '''UI Logic:''' Selecting this option reveals an '''Import Button'''.
#* '''Visibility:''' The "Number of reviews" and "Pre-submission" fields are hidden when this method is active.

=== Review Counts & Logic ===
Field labels and visibility depend on the '''Calibration for training''' setting in the General tab:

* '''Standard Label:''' "Number of reviews each reviewer is required to do."
* '''Calibration Label:''' If Calibration is enabled, the label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and a new field, '''"Number of calibrated reviews"''', becomes visible.
* '''Pre-submission Assignments:''' A checkbox labeled "Assign reviewers to review projects that have not yet been submitted" (Defaults to '''Checked''').

=== Execution ===
* '''Assign Reviewers Button:''' Visible only when required parameters are defined. Clicking this triggers the backend mapping logic.

== Dynamic Strategy Configuration ==
When '''Dynamic''' is selected, the following configuration fields are exposed:

* '''Number of reviews each reviewer is required to do:''' Integer input field.
* '''Max. number of reviews each reviewer is allowed to do:''' This field is automatically pre-populated with the value entered in the "required" field.
* '''Review topic threshold (k):'''
** '''Visibility:''' Only appears if '''Has topics?''' is enabled on the General tab.
** '''Default:''' Pre-populated with '''1'''.
** '''Tooltip:''' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
These settings are persistent across both Static and Dynamic strategies, though some are subject to conditional visibility.

{| class="wikitable"
! Field !! Visibility !! Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see the identity of their reviewers.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to assigned peers.
|-
| '''Is reviewing role-based?''' || Only if '''Has teams?''' is checked || Each team member selects a role and reviews based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Only if '''Has teams?''' is checked || Assignment logic treats the team as a single unit rather than individuals.
|}

== Technical Implementation ==
The frontend captures the current state of all visible fields and transmits the configuration to the backend API. This ensures the specific assignment parameters and conditional logic states are correctly persisted in the database.

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-03-31T03:24:02Z

Zobrook2:

= Review Strategy Tab: Frontend Documentation =

This page documents the functional behavior and UI logic for the '''Review Strategy''' tab. The interface manages how reviewers are assigned to submissions, incorporating conditional logic based on global settings defined in the "General" tab (e.g., Calibration, Topics, and Teams).

== Overview ==
The Review Strategy interface allows instructors to toggle between manual and automated assignment models. This version renames legacy strategies to improve clarity and introduces dynamic field visibility based on the system state.

== Primary Strategy Selection ==
The instructor initiates configuration via the '''Review strategy''' dropdown:
* '''Static''' (formerly "Instructor-Selected"): Used for manual or rule-based distributions.
* '''Dynamic''' (formerly "Auto-Selected"): Used for algorithmic, real-time distributions.

== Static Strategy Configuration ==
When '''Static''' is selected, the following interface elements are exposed:

=== Assignment Methods ===
Instructors select from three methods under the prompt: ''"How should reviewers be assigned?"''

# '''Round robin:''' Includes an info tooltip explaining sequential distribution.
# '''Random:''' Assignments are distributed randomly.
# '''Import File:'''
#* '''UI Logic:''' Selecting this option reveals an '''Import Button'''.
#* '''Visibility:''' The "Number of reviews" and "Pre-submission" fields are hidden when this method is active.

=== Review Counts & Logic ===
Field labels and visibility depend on the '''Calibration for training''' setting in the General tab:

* '''Standard Label:''' "Number of reviews each reviewer is required to do."
* '''Calibration Label:''' If Calibration is enabled, the label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and a new field, '''"Number of calibrated reviews"''', becomes visible.
* '''Pre-submission Assignments:''' A checkbox labeled "Assign reviewers to review projects that have not yet been submitted" (Defaults to '''Checked''').

=== Execution ===
* '''Assign Reviewers Button:''' Visible only when required parameters are defined. Clicking this triggers the backend mapping logic.

== Dynamic Strategy Configuration ==
When '''Dynamic''' is selected, the following configuration fields are exposed:

* '''Number of reviews each reviewer is required to do:''' Integer input field.
* '''Max. number of reviews each reviewer is allowed to do:''' This field is automatically pre-populated with the value entered in the "required" field.
* '''Review topic threshold (k):'''
** '''Visibility:''' Only appears if '''Has topics?''' is enabled on the General tab.
** '''Default:''' Pre-populated with '''1'''.
** '''Tooltip:''' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
These settings are persistent across both Static and Dynamic strategies, though some are subject to conditional visibility.

{| class="wikitable"
! Field !! Visibility !! Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see the identity of their reviewers.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to assigned peers.
|-
| '''Is reviewing role-based?''' || Only if '''Has teams?''' is checked || Each team member selects a role and reviews based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Only if '''Has teams?''' is checked || Assignment logic treats the team as a single unit rather than individuals.
|}

== Technical Implementation ==
The frontend captures the current state of all visible fields and transmits the configuration to the backend API. This ensures the specific assignment parameters and conditional logic states are correctly persisted in the database.

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-03-31T03:20:39Z

Zobrook2: /* Technical Communication */

= Review Strategy Tab: Required Frontend Changes =

== Overview ==
The "Review Strategy" tab manages how reviewers are assigned to submissions. This update renames existing strategies and introduces conditional UI logic based on settings in the "General" tab (e.g., Calibration, Topics, and Teams).

== Primary Strategy Selection ==
The instructor is presented with a '''Review strategy''' dropdown with two options:
* '''Static''' (formerly "Instructor-Selected")
* '''Dynamic''' (formerly "Auto-Selected")

== Static Strategy Configuration ==
If '''Static''' is selected, the following fields are exposed:

=== Assignment Methods ===
Instructors must choose '''"How should reviewers be assigned?"''' from three options:
# '''Round robin:''' (Includes an info button explaining sequential distribution).
# '''Random:''' (Reviewers assigned randomly).
# '''Import File:''' (Specifies custom mappings).
#* '''Requirement:''' If this is chosen, an '''Import Button''' must appear. The "Number of reviews" and "Pre-submission" fields (below) should disappear.

=== Review Counts & Logic ===
* '''Number of reviews each reviewer is required to do:'''
** ''Note:'' If '''Calibration for training''' is checked on the General tab, this field label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and an additional field '''"Number of calibrated reviews"''' appears.
* '''Assign reviewers to review projects that have not yet been submitted:''' A checkbox that defaults to '''Checked'''.

=== Execution ===
* '''Assign Reviewers Button:''' Must be visible when needed parameters are specified to trigger the backend mapping logic.

== Dynamic Strategy Configuration ==
If '''Dynamic''' is selected, the following fields are exposed:

* '''Number of reviews each reviewer is required to do:''' Integer input.
* '''Max. number of reviews each reviewer is allowed to do:''' Should be pre-populated automatically with the value entered in the "required" field above.
* '''Review topic threshold (k):'''
** ''Visibility:'' Only appears if '''Has topics?''' is checked on the General tab.
** ''Default:'' Pre-populated with '''1'''.
** ''Info Button Text:'' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
The following fields appear regardless of whether Static or Dynamic is chosen:

{| class="wikitable"
! Field !! Requirement !! Info Button Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see who is reviewing them.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to others.
|-
| '''Is reviewing role-based?''' || Visible only if '''Has teams?''' is checked || Every team member chooses a role and reviews contributions based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Visible only if '''Has teams?''' is checked || Teams (not individuals) are assigned to review other teams.
|}

== Technical Communication ==
The frontend captures all the above states and transmits them to the backend API to ensure the assignment configuration is persisted correctly in the database.

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-03-31T03:20:29Z

Zobrook2: /* Technical Communication */

= Review Strategy Tab: Required Frontend Changes =

== Overview ==
The "Review Strategy" tab manages how reviewers are assigned to submissions. This update renames existing strategies and introduces conditional UI logic based on settings in the "General" tab (e.g., Calibration, Topics, and Teams).

== Primary Strategy Selection ==
The instructor is presented with a '''Review strategy''' dropdown with two options:
* '''Static''' (formerly "Instructor-Selected")
* '''Dynamic''' (formerly "Auto-Selected")

== Static Strategy Configuration ==
If '''Static''' is selected, the following fields are exposed:

=== Assignment Methods ===
Instructors must choose '''"How should reviewers be assigned?"''' from three options:
# '''Round robin:''' (Includes an info button explaining sequential distribution).
# '''Random:''' (Reviewers assigned randomly).
# '''Import File:''' (Specifies custom mappings).
#* '''Requirement:''' If this is chosen, an '''Import Button''' must appear. The "Number of reviews" and "Pre-submission" fields (below) should disappear.

=== Review Counts & Logic ===
* '''Number of reviews each reviewer is required to do:'''
** ''Note:'' If '''Calibration for training''' is checked on the General tab, this field label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and an additional field '''"Number of calibrated reviews"''' appears.
* '''Assign reviewers to review projects that have not yet been submitted:''' A checkbox that defaults to '''Checked'''.

=== Execution ===
* '''Assign Reviewers Button:''' Must be visible when needed parameters are specified to trigger the backend mapping logic.

== Dynamic Strategy Configuration ==
If '''Dynamic''' is selected, the following fields are exposed:

* '''Number of reviews each reviewer is required to do:''' Integer input.
* '''Max. number of reviews each reviewer is allowed to do:''' Should be pre-populated automatically with the value entered in the "required" field above.
* '''Review topic threshold (k):'''
** ''Visibility:'' Only appears if '''Has topics?''' is checked on the General tab.
** ''Default:'' Pre-populated with '''1'''.
** ''Info Button Text:'' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
The following fields appear regardless of whether Static or Dynamic is chosen:

{| class="wikitable"
! Field !! Requirement !! Info Button Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see who is reviewing them.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to others.
|-
| '''Is reviewing role-based?''' || Visible only if '''Has teams?''' is checked || Every team member chooses a role and reviews contributions based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Visible only if '''Has teams?''' is checked || Teams (not individuals) are assigned to review other teams.
|}

== Technical Communication ==
The frontend captures all the above states and transmit them to the backend API to ensure the assignment configuration is persisted correctly in the database.

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-03-31T03:07:53Z

Zobrook2:

= Review Strategy Tab: Required Frontend Changes =

== Overview ==
The "Review Strategy" tab manages how reviewers are assigned to submissions. This update renames existing strategies and introduces conditional UI logic based on settings in the "General" tab (e.g., Calibration, Topics, and Teams).

== Primary Strategy Selection ==
The instructor is presented with a '''Review strategy''' dropdown with two options:
* '''Static''' (formerly "Instructor-Selected")
* '''Dynamic''' (formerly "Auto-Selected")

== Static Strategy Configuration ==
If '''Static''' is selected, the following fields are exposed:

=== Assignment Methods ===
Instructors must choose '''"How should reviewers be assigned?"''' from three options:
# '''Round robin:''' (Includes an info button explaining sequential distribution).
# '''Random:''' (Reviewers assigned randomly).
# '''Import File:''' (Specifies custom mappings).
#* '''Requirement:''' If this is chosen, an '''Import Button''' must appear. The "Number of reviews" and "Pre-submission" fields (below) should disappear.

=== Review Counts & Logic ===
* '''Number of reviews each reviewer is required to do:'''
** ''Note:'' If '''Calibration for training''' is checked on the General tab, this field label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and an additional field '''"Number of calibrated reviews"''' appears.
* '''Assign reviewers to review projects that have not yet been submitted:''' A checkbox that defaults to '''Checked'''.

=== Execution ===
* '''Assign Reviewers Button:''' Must be visible when needed parameters are specified to trigger the backend mapping logic.

== Dynamic Strategy Configuration ==
If '''Dynamic''' is selected, the following fields are exposed:

* '''Number of reviews each reviewer is required to do:''' Integer input.
* '''Max. number of reviews each reviewer is allowed to do:''' Should be pre-populated automatically with the value entered in the "required" field above.
* '''Review topic threshold (k):'''
** ''Visibility:'' Only appears if '''Has topics?''' is checked on the General tab.
** ''Default:'' Pre-populated with '''1'''.
** ''Info Button Text:'' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

== Global Review Settings ==
The following fields appear regardless of whether Static or Dynamic is chosen:

{| class="wikitable"
! Field !! Requirement !! Info Button Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see who is reviewing them.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to others.
|-
| '''Is reviewing role-based?''' || Visible only if '''Has teams?''' is checked || Every team member chooses a role and reviews contributions based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Visible only if '''Has teams?''' is checked || Teams (not individuals) are assigned to review other teams.
|}

== Technical Communication ==
The frontend must capture all the above states and transmit them to the backend API via the {{code|transformAssignmentRequest}} utility to ensure the assignment configuration is persisted correctly in the database.

CSC/ECE 517 Spring 2026 - E2600. Reimplement review mapping controller

2026-03-31T03:07:14Z

Zobrook2:

= Review Strategy Tab: Required Frontend Changes =

== Overview ==
The "Review Strategy" tab manages how reviewers are assigned to submissions. This update renames existing strategies and introduces conditional UI logic based on settings in the "General" tab (e.g., Calibration, Topics, and Teams).

== Primary Strategy Selection ==
The instructor is presented with a '''Review strategy''' dropdown with two options:
* '''Static''' (formerly "Instructor-Selected")
* '''Dynamic''' (formerly "Auto-Selected")

---

== Static Strategy Configuration ==
If '''Static''' is selected, the following fields are exposed:

=== Assignment Methods ===
Instructors must choose '''"How should reviewers be assigned?"''' from three options:
# '''Round robin:''' (Includes an info button explaining sequential distribution).
# '''Random:''' (Reviewers assigned randomly).
# '''Import File:''' (Specifies custom mappings).
#* '''Requirement:''' If this is chosen, an '''Import Button''' must appear. The "Number of reviews" and "Pre-submission" fields (below) should disappear.

=== Review Counts & Logic ===
* '''Number of reviews each reviewer is required to do:'''
** ''Note:'' If '''Calibration for training''' is checked on the General tab, this field label changes to: '''"Number of uncalibrated reviews each reviewer is required to do"''' and an additional field '''"Number of calibrated reviews"''' appears.
* '''Assign reviewers to review projects that have not yet been submitted:''' A checkbox that defaults to '''Checked'''.

=== Execution ===
* '''Assign Reviewers Button:''' Must be visible when needed parameters are specified to trigger the backend mapping logic.

---

== Dynamic Strategy Configuration ==
If '''Dynamic''' is selected, the following fields are exposed:

* '''Number of reviews each reviewer is required to do:''' Integer input.
* '''Max. number of reviews each reviewer is allowed to do:''' Should be pre-populated automatically with the value entered in the "required" field above.
* '''Review topic threshold (k):'''
** ''Visibility:'' Only appears if '''Has topics?''' is checked on the General tab.
** ''Default:'' Pre-populated with '''1'''.
** ''Info Button Text:'' "A topic is reviewable if the minimum number of reviews already done for the submissions on that topic is within k of the minimum number of reviews done on the least-reviewed submission on any topic."

---

== Global Review Settings ==
The following fields appear regardless of whether Static or Dynamic is chosen:

{| class="wikitable"
! Field !! Requirement !! Info Button Description
|-
| '''Is reviewing anonymous?''' || Always visible || Students cannot see who is reviewing them.
|-
| '''Are self-reviews required?''' || Always visible || Reviewers/teams must review their own work in addition to others.
|-
| '''Is reviewing role-based?''' || Visible only if '''Has teams?''' is checked || Every team member chooses a role and reviews contributions based on a role-specific rubric.
|-
| '''Are reviews to be done by teams?''' || Visible only if '''Has teams?''' is checked || Teams (not individuals) are assigned to review other teams.
|}

== Technical Communication ==
The frontend must capture all the above states and transmit them to the backend API via the {{code|transformAssignmentRequest}} utility to ensure the assignment configuration is persisted correctly in the database.