# frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module MetricHelper
          
        
      
        

          

            
            

            

              # Determine the average size of review comments in each round
          
        
      
        

          

            
            

            

              # the first entry in the returned list is the overall average
          
        
      
        

          

            
            

            

              # word count.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def volume_of_review_comments(reviewer_id)
          
        
      
        

          

            
            

            

                comments_in_round, counter_in_round = get_all_review_comments(reviewer_id)
          
        
      
        

          

            
            

            

                num_rounds = comments_in_round.count - 1 # ignore nil element (index 0)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                comments = ""
          
        
      
        

          

            
            

            

                comment_count = 0
          
        
      
        

          

            
            

            

                comments_in_round.each { |comment| comments += comment unless comment == nil}
          
        
      
        

          

            
            

            

                counter_in_round.each { |count| comment_count += count unless count == nil}
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                overall_avg_vol = (Lingua::EN::Readability.new(comments).num_words / (comment_count.zero? ? 1 : comment_count)).round(0)
          
        
      
        

          

            
            

            

                review_comments_volume = []
          
        
      
        

          

            
            

            

                review_comments_volume.push(overall_avg_vol)
          
        
      
        

          

            
            

            

                (1..num_rounds).each do |round|
          
        
      
        

          

            
            

            

                  num = Lingua::EN::Readability.new(comments_in_round[round]).num_words
          
        
      
        

          

            
            

            

                  den = (counter_in_round[round].zero? ? 1 : counter_in_round[round])
          
        
      
        

          

            
            

            

                  avg_vol_in_round = (num / den).round(0)
          
        
      
        

          

            
            

            

                  review_comments_volume.push(avg_vol_in_round)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                review_comments_volume
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Get a collection of all comments across all rounds of a review
          
        
      
        

          

            
            

            

              # as well as a count of the total number of comments. Returns the
          
        
      
        

          

            
            

            

              # above information both for totals and in a list per-round.
          
        
      
        

          

            1
            

            

              def get_all_review_comments(reviewer_id)
          
        
      
        

          

            
            

            

                comments_in_round = []
          
        
      
        

          

            
            

            

                counter_in_round = []
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                ReviewResponseMap.where(reviewed_object_id: id, reviewer_id: reviewer_id).find_each do |response_map|
          
        
      
        

          

            
            

            

                  (1..num_review_rounds + 1).each do |round|
          
        
      
        

          

            
            

            

                    comments_in_round[round] = ''
          
        
      
        

          

            
            

            

                    counter_in_round[round] = 0
          
        
      
        

          

            
            

            

                    last_response_in_current_round = response_map.response.select { |r| r.round == round }.last
          
        
      
        

          

            
            

            

                    next if last_response_in_current_round.nil?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    last_response_in_current_round.scores.each do |answer|
          
        
      
        

          

            
            

            

                      comments_in_round[round] += (answer.comments ||= '')
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                    additional_comment = last_response_in_current_round.additional_comment
          
        
      
        

          

            
            

            

                    comments_in_round[round] += additional_comment
          
        
      
        

          

            
            

            

                    counter_in_round[round] += 1
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                [comments_in_round, counter_in_round]
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module ScorableHelper
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Computes the total points awarded for all scores on the instance
          
        
      
        

          

            1
            

            

              def calculate_total_score
          
        
      
        

          

            
            

            

                # Only count the scorable questions, only when the answer is not nil (we accept nil as
          
        
      
        

          

            
            

            

                # answer for scorable questions, and they will not be counted towards the total score)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                sum = 0
          
        
      
        

          

            
            

            

                question_ids = scores.map(&:question_id)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # We use find with order here to ensure that the list of questions we get is in the same order as that of question_ids
          
        
      
        

          

            
            

            

                questions = Question.find_with_order(question_ids)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                scores.each_with_index do |score, idx|
          
        
      
        

          

            
            

            

                  question = questions[idx]
          
        
      
        

          

            
            

            

                  sum += score.answer * questions[idx].weight if !score.answer.nil? && question.scorable?
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                sum
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Returns the average score across all of the instances scores as an integer (0-100)
          
        
      
        

          

            1
            

            

              def average_score
          
        
      
        

          

            
            

            

                if maximum_score.zero?
          
        
      
        

          

            
            

            

                  0
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  ((calculate_total_score.to_f / maximum_score.to_f) * 100).round
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Returns the maximum possible total score for all scores on the instance
          
        
      
        

          

            1
            

            

              def maximum_score
          
        
      
        

          

            
            

            

                # Only count the scorable questions, only when the answer is not nil (we accept nil as
          
        
      
        

          

            
            

            

                # answer for scorable questions, and they will not be counted towards the total score)
          
        
      
        

          

            
            

            

                total_weight = 0
          
        
      
        

          

            
            

            

                question_ids = scores.map(&:question_id)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # We use find with order here to ensure that the list of questions we get is in the same order as that of question_ids
          
        
      
        

          

            
            

            

                questions = Question.find_with_order(question_ids)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                scores.each_with_index do |score, idx|
          
        
      
        

          

            
            

            

                  total_weight += questions[idx].weight unless score.answer.nil? || !questions[idx].scorable?
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                questionnaire = if scores.empty?
          
        
      
        

          

            
            

            

                                  questionnaire_by_answer(nil)
          
        
      
        

          

            
            

            

                                else
          
        
      
        

          

            
            

            

                                  questionnaire_by_answer(scores.first)
          
        
      
        

          

            
            

            

                                end
          
        
      
        

          

            
            

            

                total_weight * questionnaire.max_question_score
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def questionnaire_by_answer(answer)
          
        
      
        

          

            
            

            

                if answer.nil?
          
        
      
        

          

            
            

            

                  # Answers can be nil in cases such as "Upload File" being the only question.
          
        
      
        

          

            
            

            

                  map = ResponseMap.find(map_id)
          
        
      
        

          

            
            

            

                  # E-1973 either get the assignment from the participant or the map itself
          
        
      
        

          

            
            

            

                  assignment = map.response_assignment
          
        
      
        

          

            
            

            

                  questionnaire = Questionnaire.find(assignment.review_questionnaire_id)
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  questionnaire = Question.find(answer.question_id).questionnaire
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                questionnaire
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Answer < ApplicationRecord
          
        
      
        

          

            1
            

            

                belongs_to :response
          
        
      
        

          

            1
            

            

                belongs_to :question
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ApplicationRecord < ActiveRecord::Base
          
        
      
        

          

            1
            

            

              primary_abstract_class
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Assignment < ApplicationRecord
          
        
      
        

          

            1
            

            

              include MetricHelper
          
        
      
        

          

            1
            

            

              has_many :invitations
          
        
      
        

          

            1
            

            

              has_many :questionnaires
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def review_questionnaire_id
          
        
      
        

          

            
            

            

                Questionnaire.find_by_assignment_id id
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def num_review_rounds
          
        
      
        

          

            
            

            

                rounds_of_reviews
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class AssignmentQuestionnaire < ApplicationRecord
          
        
      
        

          

            1
            

            

              belongs_to :assignment
          
        
      
        

          

            1
            

            

              belongs_to :questionnaire
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Course < ApplicationRecord
          
        
      
        

          

            1
            

            

              belongs_to :instructor, class_name: 'User', foreign_key: 'instructor_id'
          
        
      
        

          

            1
            

            

              belongs_to :institution, foreign_key: 'institution_id'
          
        
      
        

          

            1
            

            

              validates :name, presence: true
          
        
      
        

          

            1
            

            

              validates :directory_path, presence: true
          
        
      
        

          

            1
            

            

              has_many :ta_mappings, dependent: :destroy
          
        
      
        

          

            1
            

            

              has_many :tas, through: :ta_mappings
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Returns the submission directory for the course
          
        
      
        

          

            1
            

            

              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
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Add a Teaching Assistant to the course
          
        
      
        

          

            1
            

            

              def add_ta(user)
          
        
      
        

          

            
            

            

                if user.nil?
          
        
      
        

          

            
            

            

                  return { success: false, message: "The user with id #{user.id} does not exist" }
          
        
      
        

          

            
            

            

                elsif TaMapping.exists?(ta_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(ta_id: user.id, course_id: id)
          
        
      
        

          

            
            

            

                  user.update(role: Role::TEACHING_ASSISTANT)
          
        
      
        

          

            
            

            

                  if ta_mapping.save
          
        
      
        

          

            
            

            

                    return { success: true, data: ta_mapping.slice(:course_id, :ta_id) }
          
        
      
        

          

            
            

            

                  else
          
        
      
        

          

            
            

            

                    return { success: false, message: ta_mapping.errors }
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Removes Teaching Assistant from the course
          
        
      
        

          

            1
            

            

              def remove_ta(ta_id)
          
        
      
        

          

            
            

            

                ta_mapping = ta_mappings.find_by(ta_id: ta_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.ta_id)
          
        
      
        

          

            
            

            

                ta_count = TaMapping.where(ta_id: ta_id).size - 1
          
        
      
        

          

            
            

            

                if ta_count.zero?
          
        
      
        

          

            
            

            

                  ta.update(role: Role::STUDENT)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                ta_mapping.destroy
          
        
      
        

          

            
            

            

                { success: true, ta_name: ta.name }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Creates a copy of the course
          
        
      
        

          

            1
            

            

              def copy_course
          
        
      
        

          

            
            

            

                new_course = dup
          
        
      
        

          

            
            

            

                new_course.directory_path += '_copy'
          
        
      
        

          

            
            

            

                new_course.name += '_copy'
          
        
      
        

          

            
            

            

                new_course.save
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Institution < ApplicationRecord
          
        
      
        

          

            1
            

            

              validates :name, presence: true, uniqueness: true, allow_blank: false, length: { maximum: 50 }
          
        
      
        

          

            1
            

            

              has_many :users, dependent: :restrict_with_error
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            1
            

            

              def exists?
          
        
      
        

          

            
            

            

                true
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
    
  

    

      
        

          

            1
            

            

            class Instructor < User
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Get all users whose parent is the instructor
          
        
      
        

          

            1
            

            

              def managed_users
          
        
      
        

          

            
            

            

                User.where(parent_id: id).to_a
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Node < ApplicationRecord
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Question < ApplicationRecord
          
        
      
        

          

            1
            

            

              before_create :set_seq
          
        
      
        

          

            1
            

            

              belongs_to :questionnaire # each question belongs to a specific questionnaire
          
        
      
        

          

            1
            

            

              has_many :answers, dependent: :destroy
          
        
      
        

          

            
            

            

              
          
        
      
        

          

            1
            

            

              validates :seq, presence: true, numericality: true # sequence must be numeric
          
        
      
        

          

            1
            

            

              validates :txt, length: { minimum: 0, allow_nil: false, message: "can't be nil" } # user must define text content for a question
          
        
      
        

          

            1
            

            

              validates :question_type, presence: true # user must define type for a question
          
        
      
        

          

            1
            

            

              validates :break_before, presence: true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def scorable?
          
        
      
        

          

            
            

            

                false
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

                
          
        
      
        

          

            1
            

            

              def set_seq
          
        
      
        

          

            13
            

            

                self.seq = questionnaire.questions.size + 1
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def as_json(options = {})
          
        
      
        

          

            
            

            

                  super(options.merge({
          
        
      
        

          

            
            

            

                                        only: %i[txt weight seq question_type size alternatives break_before min_label max_label created_at updated_at],
          
        
      
        

          

            
            

            

                                        include: {
          
        
      
        

          

            
            

            

                                          questionnaire: { only: %i[name id] }
          
        
      
        

          

            
            

            

                                        }
          
        
      
        

          

            
            

            

                                      })).tap do |hash|
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class QuestionnaireNode < Node
          
        
      
        

          

            1
            

            

              belongs_to :questionnaire, class_name: 'Questionnaire', foreign_key: 'node_object_id', inverse_of: false
          
        
      
        

          

            1
            

            

              belongs_to :node_object, class_name: 'Questionnaire', foreign_key: 'node_object_id', inverse_of: false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.table
          
        
      
        

          

            
            

            

                'questionnaires'
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class ReviewQuestionnaire < Questionnaire
          
        
      
        

          

            1
            

            

              def symbol
          
        
      
        

          

            12
            

            

                'review'.to_sym
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class Role < ApplicationRecord
          
        
      
        

          

            1
            

            

              validates :name, presence: true, uniqueness: true, allow_blank: false
          
        
      
        

          

            1
            

            

              belongs_to :parent, class_name: 'Role', optional: true
          
        
      
        

          

            1
            

            

              has_many :users, dependent: :nullify
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              if Role.table_exists?
          
        
      
        

          

            1
            

            

                STUDENT = find_by_name('Student')
          
        
      
        

          

            1
            

            

                INSTRUCTOR = find_by_name('Instructor')
          
        
      
        

          

            1
            

            

                ADMINISTRATOR = find_by_name('Administrator')
          
        
      
        

          

            1
            

            

                TEACHING_ASSISTANT = find_by_name('Teaching Assistant')
          
        
      
        

          

            1
            

            

                SUPER_ADMINISTRATOR = find_by_name('Super Administrator')
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def super_administrator?
          
        
      
        

          

            
            

            

                name['Super Administrator']
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def administrator?
          
        
      
        

          

            
            

            

                name['Administrator'] || super_administrator?
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def instructor?
          
        
      
        

          

            
            

            

                name['Instructor']
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def ta?
          
        
      
        

          

            
            

            

                name['Teaching Assistant']
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def student?
          
        
      
        

          

            
            

            

                name['Student']
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # returns an array of ids of all roles that are below the current role
          
        
      
        

          

            1
            

            

              def subordinate_roles
          
        
      
        

          

            
            

            

                role = Role.find_by(parent_id: id)
          
        
      
        

          

            
            

            

                return [] unless role
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                [role] + role.subordinate_roles
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # returns an array of ids of all roles that are below the current role and includes the current role
          
        
      
        

          

            1
            

            

              def subordinate_roles_and_self
          
        
      
        

          

            
            

            

                [self] + subordinate_roles
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # checks if the current role has all the privileges of the target role
          
        
      
        

          

            1
            

            

              def all_privileges_of?(target_role)
          
        
      
        

          

            
            

            

                privileges = {
          
        
      
        

          

            
            

            

                  'Student' => 1,
          
        
      
        

          

            
            

            

                  'Teaching Assistant' => 2,
          
        
      
        

          

            
            

            

                  'Instructor' => 3,
          
        
      
        

          

            
            

            

                  'Administrator' => 4,
          
        
      
        

          

            
            

            

                  'Super Administrator' => 5
          
        
      
        

          

            
            

            

                }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                privileges[name] >= privileges[target_role.name]
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # return list of all roles other than the current role
          
        
      
        

          

            1
            

            

              def other_roles
          
        
      
        

          

            
            

            

                Role.where.not(id:)
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def as_json(options = nil)
          
        
      
        

          

            
            

            

                super(options.merge({ only: %i[id name parent_id] }))
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            class User < ApplicationRecord
          
        
      
        

          

            1
            

            

              has_secure_password
          
        
      
        

          

            1
            

            

              after_initialize :set_defaults
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # name must be lowercase and unique
          
        
      
        

          

            1
            

            

              validates :name, presence: true, uniqueness: true, allow_blank: false,
          
        
      
        

          

            
            

            

                               format: { with: /\A[a-z]+\z/, message: 'must be in lowercase' }
          
        
      
        

          

            1
            

            

              validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
          
        
      
        

          

            1
            

            

              validates :password, length: { minimum: 6 }, presence: true, allow_nil: true
          
        
      
        

          

            1
            

            

              validates :full_name, presence: true, length: { maximum: 50 }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              belongs_to :role
          
        
      
        

          

            1
            

            

              belongs_to :institution, optional: true
          
        
      
        

          

            1
            

            

              belongs_to :parent, class_name: 'User', optional: true
          
        
      
        

          

            1
            

            

              has_many :users, foreign_key: 'parent_id', dependent: :nullify
          
        
      
        

          

            1
            

            

              has_many :invitations
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              scope :students, -> { where role_id: Role::STUDENT }
          
        
      
        

          

            1
            

            

              scope :tas, -> { where role_id: Role::TEACHING_ASSISTANT }
          
        
      
        

          

            1
            

            

              scope :instructors, -> { where role_id: Role::INSTRUCTOR }
          
        
      
        

          

            1
            

            

              scope :administrators, -> { where role_id: Role::ADMINISTRATOR }
          
        
      
        

          

            1
            

            

              scope :superadministrators, -> { where role_id: Role::SUPER_ADMINISTRATOR }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              delegate :student?, to: :role
          
        
      
        

          

            1
            

            

              delegate :ta?, to: :role
          
        
      
        

          

            1
            

            

              delegate :instructor?, to: :role
          
        
      
        

          

            1
            

            

              delegate :administrator?, to: :role
          
        
      
        

          

            1
            

            

              delegate :super_administrator?, to: :role
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.instantiate(record)
          
        
      
        

          

            
            

            

                case record.role
          
        
      
        

          

            
            

            

                when Role::TEACHING_ASSISTANT
          
        
      
        

          

            
            

            

                  record.becomes(Ta)
          
        
      
        

          

            
            

            

                when Role::INSTRUCTOR
          
        
      
        

          

            
            

            

                  record.becomes(Instructor)
          
        
      
        

          

            
            

            

                when Role::ADMINISTRATOR
          
        
      
        

          

            
            

            

                  record.becomes(Administrator)
          
        
      
        

          

            
            

            

                when Role::SUPER_ADMINISTRATOR
          
        
      
        

          

            
            

            

                  record.becomes(SuperAdministrator)
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  super
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Welcome email to be sent to the user after they sign up
          
        
      
        

          

            1
            

            

              def welcome_email; end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Return a user object if the user is found in the database, the input can be either email or name
          
        
      
        

          

            1
            

            

              def self.login_user(login)
          
        
      
        

          

            
            

            

                user = User.find_by(email: login)
          
        
      
        

          

            
            

            

                if user.nil?
          
        
      
        

          

            
            

            

                  short_name = login.split('@').first
          
        
      
        

          

            
            

            

                  user_list = User.where(name: short_name)
          
        
      
        

          

            
            

            

                  user = user_list.first if user_list.one?
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                user
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Reset the password for the user
          
        
      
        

          

            1
            

            

              def reset_password
          
        
      
        

          

            
            

            

                random_password = SecureRandom.alphanumeric(10)
          
        
      
        

          

            
            

            

                user.password_digest = BCrypt::Password.create(random_password)
          
        
      
        

          

            
            

            

                user.save
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Get instructor_id of the user, if the user is TA,
          
        
      
        

          

            
            

            

              # return the id of the instructor else return the id of the user for superior roles
          
        
      
        

          

            1
            

            

              def instructor_id
          
        
      
        

          

            
            

            

                case role
          
        
      
        

          

            
            

            

                when Role::INSTRUCTOR, Role::ADMINISTRATOR, Role::SUPER_ADMINISTRATOR
          
        
      
        

          

            
            

            

                  id
          
        
      
        

          

            
            

            

                when Role::TEACHING_ASSISTANT
          
        
      
        

          

            
            

            

                  my_instructor
          
        
      
        

          

            
            

            

                else
          
        
      
        

          

            
            

            

                  raise NotImplementedError, "Unknown role: #{role.name}"
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def self.from_params(params)
          
        
      
        

          

            
            

            

                user = params[:user_id] ? User.find(params[:user_id]) : User.find_by(name: params[:user][:name])
          
        
      
        

          

            
            

            

                raise "User #{params[:user_id] || params[:user][:name]} not found" if user.nil?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                user
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # This will override the default as_json method in the ApplicationRecord class and specify
          
        
      
        

          

            
            

            

              # that only the id, name, and email attributes should be included when a User object is serialized.
          
        
      
        

          

            1
            

            

              def as_json(options = {})
          
        
      
        

          

            
            

            

                super(options.merge({
          
        
      
        

          

            
            

            

                                      only: %i[id name email full_name email_on_review email_on_submission
          
        
      
        

          

            
            

            

                                               email_on_review_of_review],
          
        
      
        

          

            
            

            

                                      include:
          
        
      
        

          

            
            

            

                                      {
          
        
      
        

          

            
            

            

                                        role: { only: %i[id name] },
          
        
      
        

          

            
            

            

                                        parent: { only: %i[id name] },
          
        
      
        

          

            
            

            

                                        institution: { only: %i[id name] }
          
        
      
        

          

            
            

            

                                      }
          
        
      
        

          

            
            

            

                                    })).tap do |hash|
          
        
      
        

          

            
            

            

                  hash['parent'] ||= { id: nil, name: nil }
          
        
      
        

          

            
            

            

                  hash['institution'] ||= { id: nil, name: nil }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              def set_defaults
          
        
      
        

          

            62
            

            

                self.is_new_user = true
          
        
      
        

          

            62
            

            

                self.copy_of_emails ||= false
          
        
      
        

          

            62
            

            

                self.email_on_review ||= false
          
        
      
        

          

            62
            

            

                self.email_on_submission ||= false
          
        
      
        

          

            62
            

            

                self.email_on_review_of_review ||= false
          
        
      
        

          

            62
            

            

                self.etc_icons_on_homepage ||= true
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            require_relative 'boot'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'rails/all'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Require the gems listed in Gemfile, including any gems
          
        
      
        

          

            
            

            

            # you've limited to :test, :development, or :production.
          
        
      
        

          

            1
            

            

            Bundler.require(*Rails.groups)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            module Reimplementation
          
        
      
        

          

            1
            

            

              class Application < Rails::Application
          
        
      
        

          

            
            

            

                # Initialize configuration defaults for originally generated Rails version.
          
        
      
        

          

            1
            

            

                config.load_defaults 7.0
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Configuration for the application, engines, and railties goes here.
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # These settings can be overridden in specific environments using the files
          
        
      
        

          

            
            

            

                # in config/environments, which are processed later.
          
        
      
        

          

            
            

            

                #
          
        
      
        

          

            
            

            

                # config.time_zone = "Central Time (US & Canada)"
          
        
      
        

          

            
            

            

                # config.eager_load_paths << Rails.root.join("extras")
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Only loads a smaller set of middleware suitable for API only apps.
          
        
      
        

          

            
            

            

                # Middleware like session, flash, cookies can be added back manually.
          
        
      
        

          

            
            

            

                # Skip views, helpers and assets when generating a new resource.
          
        
      
        

          

            1
            

            

                config.api_only = true
          
        
      
        

          

            1
            

            

                config.cache_store = :redis_store, ENV['CACHE_STORE'], { expires_in: 3.days, raise_errors: false }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            require 'bundler/setup' # Set up gems listed in the Gemfile.
          
        
      
        

          

            1
            

            

            require 'bootsnap/setup' # Speed up boot time by caching expensive operations.
          
        
      
    
  

    

      
        

          

            
            

            

            # Load the Rails application.
          
        
      
        

          

            1
            

            

            require_relative 'application'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Initialize the Rails application.
          
        
      
        

          

            1
            

            

            Rails.application.initialize!
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'active_support/core_ext/integer/time'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # The test environment is used exclusively to run your application's
          
        
      
        

          

            
            

            

            # test suite. You never need to work with it otherwise. Remember that
          
        
      
        

          

            
            

            

            # your test database is "scratch space" for the test suite and is wiped
          
        
      
        

          

            
            

            

            # and recreated between test runs. Don't rely on the data there!
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            Rails.application.configure do
          
        
      
        

          

            
            

            

              # Settings specified here will take precedence over those in config/application.rb.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Turn false under Spring and add config.action_view.cache_template_loading = true.
          
        
      
        

          

            1
            

            

              config.cache_classes = false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Eager loading loads your whole application. When running a single test locally,
          
        
      
        

          

            
            

            

              # this probably isn't necessary. It's a good idea to do in a continuous integration
          
        
      
        

          

            
            

            

              # system, or in some way before deploying your code.
          
        
      
        

          

            1
            

            

              config.eager_load = ENV['CI'].present?
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Configure public file server for tests with Cache-Control for performance.
          
        
      
        

          

            1
            

            

              config.public_file_server.enabled = true
          
        
      
        

          

            1
            

            

              config.public_file_server.headers = {
          
        
      
        

          

            
            

            

                'Cache-Control' => "public, max-age=#{1.hour.to_i}"
          
        
      
        

          

            
            

            

              }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Show full error reports and disable caching.
          
        
      
        

          

            1
            

            

              config.consider_all_requests_local       = true
          
        
      
        

          

            1
            

            

              config.action_controller.perform_caching = false
          
        
      
        

          

            1
            

            

              config.cache_store = :null_store
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Raise exceptions instead of rendering exception templates.
          
        
      
        

          

            1
            

            

              config.action_dispatch.show_exceptions = false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Disable request forgery protection in test environment.
          
        
      
        

          

            1
            

            

              config.action_controller.allow_forgery_protection = false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Store uploaded files on the local file system in a temporary directory.
          
        
      
        

          

            1
            

            

              config.active_storage.service = :test
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              config.action_mailer.perform_caching = false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Tell Action Mailer not to deliver emails to the real world.
          
        
      
        

          

            
            

            

              # The :test delivery method accumulates sent emails in the
          
        
      
        

          

            
            

            

              # ActionMailer::Base.deliveries array.
          
        
      
        

          

            1
            

            

              config.action_mailer.delivery_method = :test
          
        
      
        

          

            
            

            

              # This line let us to use expect(...).to have_enqueued_job.on_queue('mailers')
          
        
      
        

          

            1
            

            

              config.active_job.queue_adapter = :test
          
        
      
        

          

            
            

            

              # Print deprecation notices to the stderr.
          
        
      
        

          

            1
            

            

              config.active_support.deprecation = :stderr
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Raise exceptions for disallowed deprecations.
          
        
      
        

          

            1
            

            

              config.active_support.disallowed_deprecation = :raise
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Tell Active Support which deprecation messages to disallow.
          
        
      
        

          

            1
            

            

              config.active_support.disallowed_deprecation_warnings = []
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Raises error for missing translations.
          
        
      
        

          

            
            

            

              # config.i18n.raise_on_missing_translations = true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Annotate rendered view with file names.
          
        
      
        

          

            
            

            

              # config.action_view.annotate_rendered_view_with_filenames = true
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # Be sure to restart your server when you modify this file.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Avoid CORS issues when API is called from the frontend app.
          
        
      
        

          

            
            

            

            # Handle Cross-Origin Resource Sharing (CORS) in order to accept cross-origin AJAX requests.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Read more: https://github.com/cyu/rack-cors
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            Rails.application.config.middleware.insert_before 0, Rack::Cors do
          
        
      
        

          

            1
            

            

              allow do
          
        
      
        

          

            1
            

            

                origins '*'
          
        
      
        

          

            1
            

            

                resource '*',
          
        
      
        

          

            
            

            

                         headers: :any,
          
        
      
        

          

            
            

            

                         methods: %i[get post put patch delete options head]
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # Be sure to restart your server when you modify this file.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Configure parameters to be filtered from the log file. Use this to limit dissemination of
          
        
      
        

          

            
            

            

            # sensitive information. See the ActiveSupport::ParameterFilter documentation for supported
          
        
      
        

          

            
            

            

            # notations and behaviors.
          
        
      
        

          

            1
            

            

            Rails.application.config.filter_parameters += %i[
          
        
      
        

          

            
            

            

              passw secret token _key crypt salt certificate otp ssn
          
        
      
        

          

            
            

            

            ]
          
        
      
    
  

    

      
        

          

            
            

            

            # Be sure to restart your server when you modify this file.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Add new inflection rules using the following format. Inflections
          
        
      
        

          

            
            

            

            # are locale specific, and you may define rules for as many different
          
        
      
        

          

            
            

            

            # locales as you wish. All of these examples are active by default:
          
        
      
        

          

            
            

            

            # ActiveSupport::Inflector.inflections(:en) do |inflect|
          
        
      
        

          

            
            

            

            #   inflect.plural /^(ox)$/i, "\\1en"
          
        
      
        

          

            
            

            

            #   inflect.singular /^(ox)en/i, "\\1"
          
        
      
        

          

            
            

            

            #   inflect.irregular "person", "people"
          
        
      
        

          

            
            

            

            #   inflect.uncountable %w( fish sheep )
          
        
      
        

          

            
            

            

            # end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # These inflection rules are supported but not enabled by default:
          
        
      
        

          

            
            

            

            # ActiveSupport::Inflector.inflections(:en) do |inflect|
          
        
      
        

          

            
            

            

            #   inflect.acronym "RESTful"
          
        
      
        

          

            
            

            

            # end
          
        
      
    
  

    

      
        

          

            1
            

            

            Rswag::Api.configure do |c|
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Specify a root folder where Swagger JSON files are located
          
        
      
        

          

            
            

            

              # This is used by the Swagger middleware to serve requests for API descriptions
          
        
      
        

          

            
            

            

              # NOTE: If you're using rswag-specs to generate Swagger, you'll need to ensure
          
        
      
        

          

            
            

            

              # that it's configured to generate files in the same folder
          
        
      
        

          

            1
            

            

              c.swagger_root = Rails.root.to_s + '/swagger'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Inject a lambda function to alter the returned Swagger prior to serialization
          
        
      
        

          

            
            

            

              # The function will have access to the rack env for the current request
          
        
      
        

          

            
            

            

              # For example, you could leverage this to dynamically assign the "host" property
          
        
      
        

          

            
            

            

              #
          
        
      
        

          

            
            

            

              #c.swagger_filter = lambda { |swagger, env| swagger['host'] = env['HTTP_HOST'] }
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            Rswag::Ui.configure do |c|
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # List the Swagger endpoints that you want to be documented through the
          
        
      
        

          

            
            

            

              # swagger-ui. The first parameter is the path (absolute or relative to the UI
          
        
      
        

          

            
            

            

              # host) to the corresponding endpoint and the second is a title that will be
          
        
      
        

          

            
            

            

              # displayed in the document selector.
          
        
      
        

          

            
            

            

              # NOTE: If you're using rspec-api to expose Swagger files
          
        
      
        

          

            
            

            

              # (under swagger_root) as JSON or YAML endpoints, then the list below should
          
        
      
        

          

            
            

            

              # correspond to the relative paths for those endpoints.
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              c.swagger_endpoint '/api-docs/v1/swagger.yaml', 'API V1 Docs'
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Add Basic Auth in case your API is private
          
        
      
        

          

            
            

            

              # c.basic_auth_enabled = true
          
        
      
        

          

            
            

            

              # c.basic_auth_credentials 'username', 'password'
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            Rails.application.routes.draw do
          
        
      
        

          

            1
            

            

              mount Rswag::Api::Engine => 'api-docs'
          
        
      
        

          

            1
            

            

              mount Rswag::Ui::Engine => 'api-docs'
          
        
      
        

          

            
            

            

              # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Defines the root path route ("/")
          
        
      
        

          

            
            

            

              # root "articles#index"
          
        
      
        

          

            1
            

            

              post '/login', to: 'authentication#login'
          
        
      
        

          

            1
            

            

              namespace :api do
          
        
      
        

          

            1
            

            

                namespace :v1 do
          
        
      
        

          

            1
            

            

                  resources :institutions
          
        
      
        

          

            1
            

            

                  resources :roles do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            
            

            

                      # Get all roles that are subordinate to a role of a logged in user
          
        
      
        

          

            1
            

            

                      get 'subordinate_roles', action: :subordinate_roles
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  resources :users do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            1
            

            

                      get 'institution/:id', action: :institution_users
          
        
      
        

          

            1
            

            

                      get ':id/managed', action: :managed_users
          
        
      
        

          

            1
            

            

                      get 'role/:name', action: :role_users
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  resources :assignments
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  resources :courses do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            1
            

            

                      get ':id/add_ta/:ta_id', action: :add_ta
          
        
      
        

          

            1
            

            

                      get ':id/tas', action: :view_tas
          
        
      
        

          

            1
            

            

                      get ':id/remove_ta/:ta_id', action: :remove_ta
          
        
      
        

          

            1
            

            

                      get ':id/copy', action: :copy
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  resources :questionnaires do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            1
            

            

                      post 'copy/:id', to: 'questionnaires#copy', as: 'copy'
          
        
      
        

          

            1
            

            

                      get 'toggle_access/:id', to: 'questionnaires#toggle_access', as: 'toggle_access'
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  resources :questions do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            1
            

            

                      get :types
          
        
      
        

          

            1
            

            

                      get 'show_all/questionnaire/:id', to:'questions#show_all#questionnaire', as: 'show_all'
          
        
      
        

          

            1
            

            

                      delete 'delete_all/questionnaire/:id', to:'questions#delete_all#questionnaire', as: 'delete_all'
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  resources :signed_up_teams do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            1
            

            

                      post '/sign_up', to: 'signed_up_teams#sign_up'
          
        
      
        

          

            1
            

            

                      post '/sign_up_student', to: 'signed_up_teams#sign_up_student'
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  resources :sign_up_topics do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            1
            

            

                      get :filter
          
        
      
        

          

            1
            

            

                      delete '/', to: 'sign_up_topics#destroy'
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  resources :invitations do
          
        
      
        

          

            1
            

            

                    get 'user/:user_id/assignment/:assignment_id/', on: :collection, action: :invitations_for_user_assignment
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  resources :account_requests do
          
        
      
        

          

            1
            

            

                    collection do
          
        
      
        

          

            1
            

            

                      get :pending, action: :pending_requests
          
        
      
        

          

            1
            

            

                      get :processed, action: :processed_requests
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            FactoryBot.define do
          
        
      
        

          

            1
            

            

              factory :user do
          
        
      
        

          

            1
            

            

                sequence(:name) { |_n| Faker::Name.name.to_s.delete(" \t\r\n").downcase }
          
        
      
        

          

            1
            

            

                sequence(:email) { |_n| Faker::Internet.email.to_s }
          
        
      
        

          

            1
            

            

                password { 'password' }
          
        
      
        

          

            1
            

            

                sequence(:full_name) { |_n| "#{Faker::Name.name}#{Faker::Name.name}".downcase }
          
        
      
        

          

            1
            

            

                role factory: :role
          
        
      
        

          

            1
            

            

                institution factory: :institution
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :role do
          
        
      
        

          

            1
            

            

                name { Faker::Name.name }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :assignment do
          
        
      
        

          

            10
            

            

                name { (Assignment.last ? "assignment#{Assignment.last.id + 1}" : 'final2').to_s }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :invitation do
          
        
      
        

          

            1
            

            

                from_user factory: :user
          
        
      
        

          

            1
            

            

                to_user factory: :user
          
        
      
        

          

            1
            

            

                assignment factory: :assignment
          
        
      
        

          

            1
            

            

                reply_status { 'W' }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :institution, class: Institution do
          
        
      
        

          

            1
            

            

                name {'North Carolina State University'}
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              if ActiveRecord::Base.connection.table_exists?(:roles)
          
        
      
        

          

            1
            

            

                factory :role_of_instructor, class: Role do
          
        
      
        

          

            1
            

            

                  name { 'Instructor' }
          
        
      
        

          

            1
            

            

                  parent_id { nil }
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :instructor, class: Instructor do
          
        
      
        

          

            1
            

            

                name {'instructor6'}
          
        
      
        

          

            1
            

            

                role {Role.where(name: 'Instructor').first || association(:role_of_instructor)}
          
        
      
        

          

            1
            

            

                fullname {'6, instructor'}
          
        
      
        

          

            1
            

            

                parent_id {1}
          
        
      
        

          

            1
            

            

                email {'instructor6@gmail.com'}
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :course, class: Course do
          
        
      
        

          

            1
            

            

                sequence(:name) { |n| "CSC517, test#{n}" }
          
        
      
        

          

            1
            

            

                instructor { Instructor.first || association(:instructor) }
          
        
      
        

          

            1
            

            

                directory_path {'csc517/test'}
          
        
      
        

          

            1
            

            

                info {'Object-Oriented Languages and Systems'}
          
        
      
        

          

            1
            

            

                private {true}
          
        
      
        

          

            1
            

            

                institution { Institution.first || association(:institution) }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            FactoryBot.define do
          
        
      
        

          

            1
            

            

              factory :questionnaire, class: Questionnaire do
          
        
      
        

          

            11
            

            

                name { 'Valid Name' }
          
        
      
        

          

            1
            

            

                instructor_id { 0 }
          
        
      
        

          

            32
            

            

                private { 0 }
          
        
      
        

          

            32
            

            

                min_question_score { 0 }
          
        
      
        

          

            30
            

            

                max_question_score { 10 }
          
        
      
        

          

            32
            

            

                questionnaire_type { 'Valid Type' }
          
        
      
        

          

            32
            

            

                display_type { 'Valid Display Type' }
          
        
      
        

          

            32
            

            

                instruction_loc { "Valid Instruction Loc" }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            1
            

            

              factory :review_questionnaire, class: ReviewQuestionnaire do
          
        
      
        

          

            15
            

            

                name { 'Valid Name' }
          
        
      
        

          

            1
            

            

                instructor_id { 0 }
          
        
      
        

          

            17
            

            

                private { 0 }
          
        
      
        

          

            17
            

            

                min_question_score { 0 }
          
        
      
        

          

            17
            

            

                max_question_score { 10 }
          
        
      
        

          

            17
            

            

                questionnaire_type { 'Valid Type' }
          
        
      
        

          

            17
            

            

                display_type { 'Valid Display Type' }
          
        
      
        

          

            17
            

            

                instruction_loc { "Valid Instruction Loc" }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            1
            

            

              factory :assignment_questionnaire, class: AssignmentQuestionnaire do
          
        
      
        

          

            6
            

            

                questionnaire_weight { 100 }
          
        
      
        

          

            7
            

            

                used_in_round { nil }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              factory :question, class: Question do
          
        
      
        

          

            1
            

            

                txt { 'Test question:' }
          
        
      
        

          

            1
            

            

                weight { 1 }
          
        
      
        

          

            1
            

            

                questionnaire { Questionnaire.first || association(:questionnaire) }
          
        
      
        

          

            1
            

            

                seq { 1.00 }
          
        
      
        

          

            1
            

            

                question_type { 'Checkbox' }
          
        
      
        

          

            1
            

            

                size { '70,1' }
          
        
      
        

          

            1
            

            

                alternatives { nil }
          
        
      
        

          

            1
            

            

                break_before { 1 }
          
        
      
        

          

            1
            

            

                max_label { nil }
          
        
      
        

          

            1
            

            

                min_label { nil }
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            
            

            

            
          
        
      
    
  

    

      
        

          

            1
            

            

            require 'rails_helper'
          
        
      
        

          

            1
            

            

            require 'simplecov'
          
        
      
        

          

            1
            

            

            SimpleCov.start
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

            describe Questionnaire, type: :model do
          
        
      
        

          

            
            

            

              # Creating dummy objects for the test with the help of let statement
          
        
      
        

          

            36
            

            

              let(:role) {Role.create(name: 'Instructor', parent_id: nil, id: 2, default_page_id: nil)}
          
        
      
        

          

            36
            

            

              let(:instructor) { Instructor.create(name: 'testinstructor', email: 'test@test.com', full_name: 'Test Instructor', password: '123456', role: role) }
          
        
      
        

          

            19
            

            

              let(:questionnaire) { FactoryBot.build(:questionnaire, { id: 1, name: 'abc', instructor_id: instructor.id }) }
          
        
      
        

          

            3
            

            

              let(:questionnaire1) { FactoryBot.build(:questionnaire, { id: 2, name: 'xyz', max_question_score: 20, instructor_id: instructor.id }) }
          
        
      
        

          

            3
            

            

              let(:questionnaire3) { FactoryBot.build(:review_questionnaire, { id: 3, name: 'pqr', instructor_id: instructor.id }) }
          
        
      
        

          

            3
            

            

              let(:question1) { questionnaire.questions.build(weight: 1, id: 1, seq: 1, txt: "que 1", question_type: "Scale", break_before: true) }
          
        
      
        

          

            3
            

            

              let(:question2) { questionnaire.questions.build(weight: 10, id: 2, seq: 2, txt: "que 2", question_type: "Checkbox", break_before: true) }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#name' do
          
        
      
        

          

            
            

            

                # Test validates the name of the questionnaire
          
        
      
        

          

            1
            

            

                it 'returns the name of the Questionnaire' do
          
        
      
        

          

            
            

            

                  # Act Assert
          
        
      
        

          

            1
            

            

                  expect(questionnaire.name).to eq('abc')
          
        
      
        

          

            1
            

            

                  expect(questionnaire1.name).to eq('xyz')
          
        
      
        

          

            1
            

            

                  expect(questionnaire3.name).to eq('pqr')
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Test ensures that the name field of the questionnaire is not blank
          
        
      
        

          

            1
            

            

                it 'Validate presence of name which cannot be blank' do
          
        
      
        

          

            
            

            

                  # Arrange
          
        
      
        

          

            1
            

            

                  questionnaire.name = '  '
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Act Assert
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Test ensures that the name field of the questionnaire is unique per instructor
          
        
      
        

          

            1
            

            

                it 'Validate name field must be unique per instructor' do
          
        
      
        

          

            
            

            

                  # Arrange Act
          
        
      
        

          

            1
            

            

                  questionnaire.save!
          
        
      
        

          

            1
            

            

                  questionnaire1.name = questionnaire.name
          
        
      
        

          

            1
            

            

                  questionnaire3.name = questionnaire.name
          
        
      
        

          

            1
            

            

                  instructor2 = Instructor.create(name: 'testinstructortwo', email: 'test2@test.com', full_name: 'Test Instructor 2', password: '123456', role: role)
          
        
      
        

          

            1
            

            

                  instructor2.save!
          
        
      
        

          

            1
            

            

                  questionnaire3.instructor_id = instructor2.id
          
        
      
        

          

            
            

            

                  # Assert
          
        
      
        

          

            1
            

            

                  expect(questionnaire).to be_valid
          
        
      
        

          

            1
            

            

                  expect(questionnaire1).not_to be_valid
          
        
      
        

          

            1
            

            

                  expect(questionnaire3).to be_valid
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#instructor_id' do
          
        
      
        

          

            
            

            

                # Test validates the instructor id in the questionnaire 
          
        
      
        

          

            1
            

            

                it 'returns the instructor id' do
          
        
      
        

          

            1
            

            

                  expect(questionnaire.instructor_id).to eq(instructor.id)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#maximum_score' do
          
        
      
        

          

            
            

            

                # Test validates the maximum score in the questionnaire 
          
        
      
        

          

            1
            

            

                it 'validate maximum score' do
          
        
      
        

          

            1
            

            

                  expect(questionnaire.max_question_score).to eq(10)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Test ensures maximum score is an integer
          
        
      
        

          

            1
            

            

                it 'validate maximum score is integer' do
          
        
      
        

          

            1
            

            

                  expect(questionnaire.max_question_score).to eq(10)
          
        
      
        

          

            1
            

            

                  questionnaire.max_question_score = 'a'
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            1
            

            

                  questionnaire.max_question_score = 1.1
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Test ensures maximum score is positive
          
        
      
        

          

            1
            

            

                it 'validate maximum score should be positive' do
          
        
      
        

          

            1
            

            

                  expect(questionnaire.max_question_score).to eq(10)
          
        
      
        

          

            1
            

            

                  questionnaire.max_question_score = -10
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            1
            

            

                  questionnaire.max_question_score = 0
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Test ensures maximum score is greater than the minimum score
          
        
      
        

          

            1
            

            

                it 'validate maximum score should be bigger than minimum score' do
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  expect(questionnaire).to be_valid
          
        
      
        

          

            1
            

            

                  questionnaire.max_question_score = 0
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            1
            

            

                  questionnaire.max_question_score = 2
          
        
      
        

          

            1
            

            

                  questionnaire.min_question_score = 3
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#minimum_score' do
          
        
      
        

          

            
            

            

                # Test validates minimum score of a questionnaire
          
        
      
        

          

            1
            

            

                it 'validate minimum score' do
          
        
      
        

          

            1
            

            

                  questionnaire.min_question_score = 5
          
        
      
        

          

            1
            

            

                  expect(questionnaire.min_question_score).to eq(5)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Test ensures minimum score is smaller than maximum score
          
        
      
        

          

            1
            

            

                it 'validate minimum should be smaller than maximum' do
          
        
      
        

          

            1
            

            

                  expect(questionnaire.min_question_score).to eq(0)
          
        
      
        

          

            1
            

            

                  questionnaire.min_question_score = 10
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            1
            

            

                  questionnaire.min_question_score = 0
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                # Test ensures minimum score is an integer
          
        
      
        

          

            1
            

            

                it 'validate minimum score is integer' do
          
        
      
        

          

            1
            

            

                  expect(questionnaire.min_question_score).to eq(0)
          
        
      
        

          

            1
            

            

                  questionnaire.min_question_score = 'a'
          
        
      
        

          

            1
            

            

                  expect(questionnaire).not_to be_valid
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe 'associations' do
          
        
      
        

          

            
            

            

                # Test validates the association that a questionnaire comprises of several questions
          
        
      
        

          

            1
            

            

                it 'has many questions' do
          
        
      
        

          

            1
            

            

                  expect(questionnaire.questions).to include(question1, question2)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '.copy_questionnaire_details' do
          
        
      
        

          

            
            

            

            # Test ensures calls from the method copy_questionnaire_details
          
        
      
        

          

            1
            

            

                it 'allowing calls from copy_questionnaire_details' do
          
        
      
        

          

            1
            

            

                  allow(Questionnaire).to receive(:find).with('1').and_return(questionnaire)
          
        
      
        

          

            1
            

            

                  allow(Question).to receive(:where).with(questionnaire_id: '1').and_return([Question])
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

                # Test ensures creation of a copy of given questionnaire
          
        
      
        

          

            
            

            

            # Combined two tests into one to avoid performing the same functionalities again to test another feature.
          
        
      
        

          

            1
            

            

                it 'creates a copy of the questionnaire' do
          
        
      
        

          

            1
            

            

                  instructor.save!
          
        
      
        

          

            1
            

            

                  questionnaire.save!
          
        
      
        

          

            1
            

            

                  question1.save!
          
        
      
        

          

            1
            

            

                  question2.save!
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Stub the where method to return the questions associated with the original questionnaire
          
        
      
        

          

            1
            

            

                  allow(questionnaire).to receive_message_chain(:questions, :each).and_yield(question1).and_yield(question2)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Call the copy_questionnaire_details method
          
        
      
        

          

            1
            

            

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

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Assertions
          
        
      
        

          

            1
            

            

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

          

            1
            

            

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

          

            1
            

            

                  expect(copied_questionnaire.created_at).to be_within(1.second).of(Time.zone.now)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # Verify that the copied questionnaire has associated questions
          
        
      
        

          

            1
            

            

                  expect(copied_questionnaire.questions.count).to eq(2)
          
        
      
        

          

            1
            

            

                  expect(copied_questionnaire.questions.first.txt).to eq(question1.txt)
          
        
      
        

          

            1
            

            

                  expect(copied_questionnaire.questions.second.txt).to eq(question2.txt)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # This is the beginning of the skeleton implementation
          
        
      
        

          

            1
            

            

              describe '#get_weighted_score' do
          
        
      
        

          

            1
            

            

                before :each do
          
        
      
        

          

            4
            

            

                  @questionnaire = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            4
            

            

                  @assignment = FactoryBot.create(:assignment)
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                context 'when the assignment has a round' do
          
        
      
        

          

            1
            

            

                  it 'computes the weighted score using the questionnaire symbol with the round appended' do
          
        
      
        

          

            
            

            

                    # Test case 1
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    FactoryBot.create(:assignment_questionnaire, { assignment_id: @assignment.id, questionnaire_id: @questionnaire.id, used_in_round: 1 })
          
        
      
        

          

            1
            

            

                    scores = { "#{@questionnaire.symbol}#{1}".to_sym => { scores: { avg: 100 } } }
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.get_weighted_score(@assignment, scores)).to eq(100)
          
        
      
        

          

            
            

            

                    # Test case 2
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    scores = { "#{@questionnaire.symbol}#{1}".to_sym => { scores: { avg: 75 } } }
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.get_weighted_score(@assignment, scores)).to eq(75)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when the assignment does not have a round' do
          
        
      
        

          

            1
            

            

                  it 'computes the weighted score using the questionnaire symbol' do
          
        
      
        

          

            
            

            

                    # Test case 3
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    FactoryBot.create(:assignment_questionnaire, { assignment_id: @assignment.id, questionnaire_id: @questionnaire.id })
          
        
      
        

          

            1
            

            

                    scores = { @questionnaire.symbol => { scores: { avg: 100 } } }
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.get_weighted_score(@assignment, scores)).to eq(100)
          
        
      
        

          

            
            

            

                    # Test case 4
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    scores = { @questionnaire.symbol => { scores: { avg: 75 } } }
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.get_weighted_score(@assignment, scores)).to eq(75)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                describe "#compute_weighted_score" do
          
        
      
        

          

            1
            

            

                  before :each do
          
        
      
        

          

            2
            

            

                    @questionnaire = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            2
            

            

                    @assignment = FactoryBot.create(:assignment)
          
        
      
        

          

            2
            

            

                    FactoryBot.create(:assignment_questionnaire, { assignment_id: @assignment.id, questionnaire_id: @questionnaire.id, questionnaire_weight: 50 })
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  context "when the average score is nil" do
          
        
      
        

          

            1
            

            

                    it "returns 0" do
          
        
      
        

          

            
            

            

                      # Test scenario
          
        
      
        

          

            
            

            

                      # Arrange
          
        
      
        

          

            1
            

            

                      scores = { @questionnaire.symbol => { scores: { avg: nil } } }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Act Assert
          
        
      
        

          

            1
            

            

                      expect(@questionnaire.compute_weighted_score(@questionnaire.symbol, @assignment, scores)).to eq(0)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  context "when the average score is not nil" do
          
        
      
        

          

            1
            

            

                    it "calculates the weighted score based on the questionnaire weight" do
          
        
      
        

          

            
            

            

                      # Test scenario
          
        
      
        

          

            
            

            

                      # Arrange
          
        
      
        

          

            1
            

            

                      scores = { @questionnaire.symbol => { scores: { avg: 75 } } }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                      # Act Assert
          
        
      
        

          

            1
            

            

                      expect(@questionnaire.compute_weighted_score(@questionnaire.symbol, @assignment, scores)).to eq(75 * 0.5)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            1
            

            

              describe "#true_false_questions?" do
          
        
      
        

          

            1
            

            

                before :each do
          
        
      
        

          

            2
            

            

                  @questionnaire = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                context "when there are true/false questions" do
          
        
      
        

          

            1
            

            

                  it "returns true" do
          
        
      
        

          

            
            

            

                    # Test scenario 2: Single question with type 'Checkbox'
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    @questionnaire.questions.create(weight: 1, id: 1, seq: 1, txt: "que 1", question_type: "Checkbox", break_before: true)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.true_false_questions?).to eq(true)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Test scenario 1: Multiple questions with type 'Checkbox'
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    @questionnaire.questions.create(weight: 1, id: 2, seq: 1, txt: "que 1", question_type: "Checkbox", break_before: true)
          
        
      
        

          

            1
            

            

                    @questionnaire.questions.create(weight: 1, id: 3, seq: 1, txt: "que 1", question_type: "Checkbox", break_before: true)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.true_false_questions?).to eq(true)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context "when there are no true/false questions" do
          
        
      
        

          

            1
            

            

                  it "returns false" do
          
        
      
        

          

            
            

            

                    # Test scenario 2: Single question with no 'Checkbox' type
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    @questionnaire.questions.create(weight: 1, id: 1, seq: 1, txt: "que 1", question_type: "Scale", break_before: true)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.true_false_questions?).to eq(false)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Test scenario 1: Multiple questions with no 'Checkbox' type
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    @questionnaire.questions.create(weight: 1, id: 2, seq: 1, txt: "que 1", question_type: "Scale", break_before: true)
          
        
      
        

          

            1
            

            

                    @questionnaire.questions.create(weight: 1, id: 3, seq: 1, txt: "que 1", question_type: "Scale", break_before: true)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            1
            

            

                    expect(@questionnaire.true_false_questions?).to eq(false)
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            1
            

            

              describe "#delete" do
          
        
      
        

          

            1
            

            

                context "when there are assignments using the questionnaire" do
          
        
      
        

          

            1
            

            

                  it "raises an error with a message asking if the user wants to delete the assignment" do
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    questionnaire_single_assignment = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            1
            

            

                    single_assignment = FactoryBot.create(:assignment)
          
        
      
        

          

            1
            

            

                    FactoryBot.create(:assignment_questionnaire, { assignment_id: single_assignment.id, questionnaire_id: questionnaire_single_assignment.id})
          
        
      
        

          

            1
            

            

                    questionnaire_multi_assignment = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            1
            

            

                    multi_assignment1 = FactoryBot.create(:assignment)
          
        
      
        

          

            1
            

            

                    FactoryBot.create(:assignment_questionnaire, { assignment_id: multi_assignment1.id, questionnaire_id: questionnaire_multi_assignment.id})
          
        
      
        

          

            1
            

            

                    multi_assignment2 = FactoryBot.create(:assignment)
          
        
      
        

          

            1
            

            

                    FactoryBot.create(:assignment_questionnaire, { assignment_id: multi_assignment2.id, questionnaire_id: questionnaire_multi_assignment.id})
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Test scenario 1
          
        
      
        

          

            
            

            

                    # Given: There are assignments using the questionnaire
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: An error is raised with a message asking if the user wants to delete the assignment
          
        
      
        

          

            2
            

            

                    expect { questionnaire_single_assignment.delete }.to raise_exception(RuntimeError) do |error|
          
        
      
        

          

            1
            

            

                      expect(error.message).to match(/^The assignment .* uses this questionnaire/)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Test scenario 2
          
        
      
        

          

            1
            

            

                    assignment1_pattern = /^The assignment #{Regexp.escape(multi_assignment1.name)} uses this questionnaire/
          
        
      
        

          

            1
            

            

                    assignment2_pattern = /^The assignment #{Regexp.escape(multi_assignment2.name)} uses this questionnaire/
          
        
      
        

          

            
            

            

                    # Given: There are multiple assignments using the questionnaire
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: An error is raised for each assignment with a message asking if the user wants to delete the assignment
          
        
      
        

          

            2
            

            

                    expect { questionnaire_multi_assignment.delete }.to raise_exception(RuntimeError) do |error|
          
        
      
        

          

            1
            

            

                      expect(error.message).to match(assignment1_pattern)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            1
            

            

                    multi_assignment1.destroy!
          
        
      
        

          

            2
            

            

                    expect { questionnaire_multi_assignment.delete }.to raise_exception(RuntimeError) do |error|
          
        
      
        

          

            1
            

            

                      expect(error.message).to match(assignment2_pattern)
          
        
      
        

          

            
            

            

                    end
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context "when there are no assignments using the questionnaire" do
          
        
      
        

          

            1
            

            

                  it "deletes all the questions associated with the questionnaire" do
          
        
      
        

          

            
            

            

                    # Test scenario 1
          
        
      
        

          

            
            

            

                    # Given: There are no assignments using the questionnaire
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: All the questions associated with the questionnaire are deleted
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    questionnaire_one_question = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            1
            

            

                    question1 = questionnaire_one_question.questions.build(weight: 1, id: 1, seq: 1, txt: "que 1", question_type: "Scale", break_before: true)
          
        
      
        

          

            1
            

            

                    question1.save!
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Act
          
        
      
        

          

            1
            

            

                    questionnaire_one_question.delete
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Assert
          
        
      
        

          

            1
            

            

                    expect(Question.find_by(id: question1.id)).to be_nil
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Test scenario 2
          
        
      
        

          

            
            

            

                    # Given: There are no assignments using the questionnaire and there are multiple questions
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: All the questions associated with the questionnaire are deleted
          
        
      
        

          

            
            

            

                    # Arrange
          
        
      
        

          

            1
            

            

                    questionnaire_multi_question = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            1
            

            

                    question1 = questionnaire_multi_question.questions.build(weight: 1, id: 1, seq: 1, txt: "que 1", question_type: "Scale", break_before: true)
          
        
      
        

          

            1
            

            

                    question1.save!
          
        
      
        

          

            1
            

            

                    question2 = questionnaire_multi_question.questions.build(weight: 1, id: 2, seq: 1, txt: "que 1", question_type: "Scale", break_before: true)
          
        
      
        

          

            1
            

            

                    question2.save!
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Act
          
        
      
        

          

            1
            

            

                    questionnaire_multi_question.delete
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Assert
          
        
      
        

          

            1
            

            

                    expect(Question.find_by(id: question1.id)).to be_nil
          
        
      
        

          

            1
            

            

                    expect(Question.find_by(id: question2.id)).to be_nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it "deletes the questionnaire node if it exists" do
          
        
      
        

          

            
            

            

                    # Test scenario 1
          
        
      
        

          

            
            

            

                    # Given: There are no assignments using the questionnaire and the questionnaire node exists
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: The questionnaire node is deleted
          
        
      
        

          

            1
            

            

                    questionnaire = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            1
            

            

                    q_node = QuestionnaireNode.create(parent_id: 0, node_object_id: questionnaire.id, type: 'QuestionnaireNode')
          
        
      
        

          

            
            

            

                    # Act
          
        
      
        

          

            1
            

            

                    questionnaire.delete
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Assert
          
        
      
        

          

            1
            

            

                    expect(QuestionnaireNode.find_by(id: q_node.id)).to be_nil
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Test scenario 2
          
        
      
        

          

            
            

            

                    # Given: There are no assignments using the questionnaire and the questionnaire node does not exist
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: No error is raised and the method completes successfully
          
        
      
        

          

            1
            

            

                    questionnaire = FactoryBot.create(:review_questionnaire, { instructor_id: instructor.id })
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Act Assert
          
        
      
        

          

            2
            

            

                    expect { questionnaire.delete }.not_to raise_error
          
        
      
        

          

            1
            

            

                    expect(Questionnaire.find_by(id: questionnaire.id)).to be_nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                  # The below tests were redundant
          
        
      
        

          

            
            

            

                  # it "deletes the questionnaire" do
          
        
      
        

          

            
            

            

                    # Test scenario 1
          
        
      
        

          

            
            

            

                    # Given: There are no assignments using the questionnaire
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: The questionnaire is deleted
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

                    # Test scenario 2
          
        
      
        

          

            
            

            

                    # Given: There are no assignments using the questionnaire and there are multiple questionnaires
          
        
      
        

          

            
            

            

                    # When: The delete method is called
          
        
      
        

          

            
            

            

                    # Then: The questionnaire is deleted
          
        
      
        

          

            
            

            

                    # end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#name_is_unique' do
          
        
      
        

          

            1
            

            

                context 'when no other questionnaire with the same name exists for the same instructor' do
          
        
      
        

          

            1
            

            

                  it 'does not add error' do
          
        
      
        

          

            1
            

            

                    questionnaire.name_is_unique
          
        
      
        

          

            1
            

            

                    expect(questionnaire.errors[:name]).to_not include('must be unique')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when two questionnaires with the same name exists for the same instructor' do
          
        
      
        

          

            1
            

            

                  it 'adds error' do
          
        
      
        

          

            1
            

            

                    existing_questionnaire = FactoryBot.create(:questionnaire, instructor: instructor)
          
        
      
        

          

            1
            

            

                    duplicate_question = FactoryBot.create(:questionnaire, instructor: instructor)
          
        
      
        

          

            1
            

            

                    duplicate_question.name_is_unique
          
        
      
        

          

            1
            

            

                    expect(duplicate_question.errors[:name]).to include('must be unique')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when two questionnaires have the same name for different instructors' do
          
        
      
        

          

            1
            

            

                  it 'does not throw an error' do
          
        
      
        

          

            
            

            

                    ## Creating a different instructor for this test.
          
        
      
        

          

            1
            

            

                    instructor2 = Instructor.create(name: 'testinstructortwo', email: 'test2@test.com', full_name: 'Test Instructor 2', password: '123456', role: role)
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    original_questionnaire = FactoryBot.create(:questionnaire, instructor: instructor)
          
        
      
        

          

            1
            

            

                    new_questionnaire = FactoryBot.create(:questionnaire, instructor: instructor2)
          
        
      
        

          

            1
            

            

                    new_questionnaire.name_is_unique
          
        
      
        

          

            1
            

            

                    expect(new_questionnaire.errors[:name]).to_not include('must be unique')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when two questionnaires have different names for the same instructor' do
          
        
      
        

          

            1
            

            

                  it 'does not throw an error' do
          
        
      
        

          

            1
            

            

                    original_questionnaire = FactoryBot.create(:questionnaire, instructor: instructor)
          
        
      
        

          

            1
            

            

                    new_questionnaire = FactoryBot.create(:questionnaire, instructor: instructor, name: "Super cool new questionnaire")
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                    new_questionnaire.name_is_unique
          
        
      
        

          

            1
            

            

                    expect(new_questionnaire.errors[:name]).to_not include('must be unique')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                context 'when any of the required values is missing' do
          
        
      
        

          

            1
            

            

                  it 'returns nothing if id is nil' do
          
        
      
        

          

            1
            

            

                    questionnaire.id = nil
          
        
      
        

          

            1
            

            

                    result = questionnaire.name_is_unique
          
        
      
        

          

            1
            

            

                    expect(result).to be_nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it 'returns nothing if name is nil' do
          
        
      
        

          

            1
            

            

                    questionnaire.name = nil
          
        
      
        

          

            1
            

            

                    result = questionnaire.name_is_unique
          
        
      
        

          

            1
            

            

                    expect(result).to be_nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it 'returns nothing if instructor_id is nil' do
          
        
      
        

          

            1
            

            

                    questionnaire.instructor_id = nil
          
        
      
        

          

            1
            

            

                    result = questionnaire.name_is_unique
          
        
      
        

          

            1
            

            

                    expect(result).to be_nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

              describe '#min_less_than_max' do
          
        
      
        

          

            1
            

            

                context 'when either value is not there' do
          
        
      
        

          

            1
            

            

                  it 'returns nil if min_score is nil.' do
          
        
      
        

          

            1
            

            

                    questionnaire = FactoryBot.create( :questionnaire, instructor: instructor)
          
        
      
        

          

            
            

            

                    ## Must be added here or it will not pass validation when being created.
          
        
      
        

          

            1
            

            

                    questionnaire.min_question_score = nil
          
        
      
        

          

            1
            

            

                    result = questionnaire.min_less_than_max
          
        
      
        

          

            1
            

            

                    expect(result).to be_nil
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                it 'returns nil if max_score is nil.' do
          
        
      
        

          

            1
            

            

                  questionnaire = FactoryBot.create( :questionnaire, instructor: instructor)
          
        
      
        

          

            
            

            

                  ## Must be added here or it will not pass validation when being created.
          
        
      
        

          

            1
            

            

                  questionnaire.max_question_score = nil
          
        
      
        

          

            1
            

            

                  result = questionnaire.min_less_than_max
          
        
      
        

          

            1
            

            

                  expect(result).to be_nil
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            1
            

            

                context 'when it is given two integers' do
          
        
      
        

          

            1
            

            

                  it 'adds an error if min is greater than max' do
          
        
      
        

          

            1
            

            

                    questionnaire = FactoryBot.create( :questionnaire, instructor: instructor)
          
        
      
        

          

            1
            

            

                    questionnaire.max_question_score = 20
          
        
      
        

          

            1
            

            

                    questionnaire.min_question_score = 25 ## min is now greater than max.
          
        
      
        

          

            1
            

            

                    questionnaire.min_less_than_max
          
        
      
        

          

            1
            

            

                    expect(questionnaire.errors[:min_question_score]).to include('must be less than max question score')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            1
            

            

                  it 'adds an error if min is equal to max' do
          
        
      
        

          

            1
            

            

                    questionnaire = FactoryBot.create( :questionnaire, instructor: instructor)
          
        
      
        

          

            1
            

            

                    questionnaire.max_question_score = 25
          
        
      
        

          

            1
            

            

                    questionnaire.min_question_score = 25 ## min is now equal to max.
          
        
      
        

          

            1
            

            

                    questionnaire.min_less_than_max
          
        
      
        

          

            1
            

            

                    expect(questionnaire.errors[:min_question_score]).to include('must be less than max question score')
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            1
            

            

                  it 'does not add an error if min is less than max' do
          
        
      
        

          

            1
            

            

                    questionnaire = FactoryBot.create( :questionnaire, instructor: instructor)
          
        
      
        

          

            1
            

            

                    questionnaire.max_question_score = 25
          
        
      
        

          

            1
            

            

                    questionnaire.min_question_score = 20 ## min is now less than max.
          
        
      
        

          

            1
            

            

                    questionnaire.min_less_than_max
          
        
      
        

          

            1
            

            

                    expect(questionnaire.errors[:min_question_score]).to be_empty
          
        
      
        

          

            
            

            

                  end
          
        
      
        

          

            
            

            

                end
          
        
      
        

          

            
            

            

              end
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            
            

            

            # This file is copied to spec/ when you run 'rails generate rspec:install'
          
        
      
        

          

            1
            

            

            require 'spec_helper'
          
        
      
        

          

            1
            

            

            ENV['RAILS_ENV'] ||= 'test'
          
        
      
        

          

            1
            

            

            require_relative '../config/environment'
          
        
      
        

          

            
            

            

            # Prevent database truncation if the environment is production
          
        
      
        

          

            1
            

            

            abort("The Rails environment is running in production mode!") if Rails.env.production?
          
        
      
        

          

            1
            

            

            require 'rspec/rails'
          
        
      
        

          

            
            

            

            # Add additional requires below this line. Rails is not loaded until this point!
          
        
      
        

          

            1
            

            

            require 'support/factory_bot'
          
        
      
        

          

            
            

            

            # Requires supporting ruby files with custom matchers and macros, etc, in
          
        
      
        

          

            
            

            

            # spec/support/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
          
        
      
        

          

            
            

            

            # run as spec files by default. This means that files in spec/support that end
          
        
      
        

          

            
            

            

            # in _spec.rb will both be required and run as specs, causing the specs to be
          
        
      
        

          

            
            

            

            # run twice. It is recommended that you do not name files matching this glob to
          
        
      
        

          

            
            

            

            # end with _spec.rb. You can configure this pattern with the --pattern
          
        
      
        

          

            
            

            

            # option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # The following line is provided for convenience purposes. It has the downside
          
        
      
        

          

            
            

            

            # of increasing the boot-up time by auto-requiring all files in the support
          
        
      
        

          

            
            

            

            # directory. Alternatively, in the individual `*_spec.rb` files, manually
          
        
      
        

          

            
            

            

            # require only the support files necessary.
          
        
      
        

          

            
            

            

            #
          
        
      
        

          

            
            

            

            # Dir[Rails.root.join('spec', 'support', '**', '*.rb')].sort.each { |f| require f }
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

            # Checks for pending migrations and applies them before tests are run.
          
        
      
        

          

            
            

            

            # If you are not using ActiveRecord, you can remove these lines.
          
        
      
        

          

            
            

            

            begin
          
        
      
        

          

            1
            

            

              ActiveRecord::Migration.maintain_test_schema!
          
        
      
        

          

            
            

            

            rescue ActiveRecord::PendingMigrationError => e
          
        
      
        

          

            
            

            

              abort e.to_s.strip
          
        
      
        

          

            
            

            

            end
          
        
      
        

          

            1
            

            

            RSpec.configure do |config|
          
        
      
        

          

            
            

            

              # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
          
        
      
        

          

            1
            

            

              config.fixture_path = "#{::Rails.root}/spec/fixtures"
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # If you're not using ActiveRecord, or you'd prefer not to run each of your
          
        
      
        

          

            
            

            

              # examples within a transaction, remove the following line or assign false
          
        
      
        

          

            
            

            

              # instead of true.
          
        
      
        

          

            1
            

            

              config.use_transactional_fixtures = true
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # You can uncomment this line to turn off ActiveRecord support entirely.
          
        
      
        

          

            
            

            

              # config.use_active_record = false
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # RSpec Rails can automatically mix in different behaviours to your tests
          
        
      
        

          

            
            

            

              # based on their file location, for example enabling you to call `get` and
          
        
      
        

          

            
            

            

              # `post` in specs under `spec/controllers`.
          
        
      
        

          

            
            

            

              #
          
        
      
        

          

            
            

            

              # You can disable this behaviour by removing the line below, and instead
          
        
      
        

          

            
            

            

              # explicitly tag your specs with their type, e.g.:
          
        
      
        

          

            
            

            

              #
          
        
      
        

          

            
            

            

              #     RSpec.describe UsersController, type: :controller do
          
        
      
        

          

            
            

            

              #       # ...
          
        
      
        

          

            
            

            

              #     end
          
        
      
        

          

            
            

            

              #
          
        
      
        

          

            
            

            

              # The different available types are documented in the features, such as in
          
        
      
        

          

            
            

            

              # https://relishapp.com/rspec/rspec-rails/docs
          
        
      
        

          

            1
            

            

              config.infer_spec_type_from_file_location!
          
        
      
        

          

            
            

            

            
          
        
      
        

          

            
            

            

              # Filter lines from Rails gems in backtraces.
          
        
      
        

          

            1
            

            

              config.filter_rails_from_backtrace!
          
        
      
        

          

            
            

            

              # arbitrary gems may also be filtered via:
          
        
      
        

          

            
            

            

              # config.filter_gems_from_backtrace("gem name")
          
        
      
        

          

            
            

            

            end
          
        
      
    
  

    

      
        

          

            1
            

            

            RSpec.configure do |config|
          
        
      
        

          

            1
            

            

              config.include FactoryBot::Syntax::Methods
          
        
      
        

          

            
            

            

            end