SampleUnitTestFile.rb

SampleUnitTestFile.rb

require 'rails_helper'

RSpec.describe PracticeSessionQuestionFiller, type: :service do
  context 'creating' do
    let(:section) { create(:act_section) }
    let(:passages) do
      passage_types = create_list(:act_passage_type, 20, section: section)
      create_list(:act_passage, 100, passage_type: passage_types.sample, section: section)
      Act::Passage.where(section_id: section.id)
    end
    let(:total_questions) { 15 }

    describe 'validation' do
      it 'errors if missing total_questions' do
        params = { section: section, passages: passages }
        expect { described_class.new(params) }.to raise_error(ArgumentError)
      end

      it 'errors if missing passages' do
        params = { total_questions: total_questions, section: section }
        expect { described_class.new(params) }.to raise_error(ArgumentError)
      end

      it 'errors if missing section' do
        params = { total_questions: total_questions, passages: passages }
        expect { described_class.new(params) }.to raise_error(ArgumentError)
      end

      it 'errors if total questions isn\'t an integer' do
        params = { total_questions: '15', section: section, passages: passages }
        expect { described_class.new(params) }.to raise_error(TypeError)
      end

      # changes section to integer
      it 'errors if section isn\'t an section' do
        params = { total_questions: total_questions, section: section.id, passages: passages }
        expect { described_class.new(params) }.to raise_error(TypeError)
      end

      it 'errors if passages isn\'t an Passage::ARAL' do
        params = { total_questions: total_questions, section: section, passages: passages.first }
        expect { described_class.new(params) }.to raise_error(TypeError)
      end

      it 'creates without failure' do
        params = { total_questions: total_questions, section: section, passages: passages }
        expect(described_class.new(params)).to be_kind_of(described_class)
      end
    end
  end

  context 'created' do
    let(:section) { create(:act_section) }
    let(:passages) do
      passage_types = create_list(:act_passage_type, 20, section: section)
      create_list(:act_passage, 40, passage_type: passage_types.sample, section: section)
      Act::Passage.where(section_id: section.id)
    end

    let(:total_questions) { 15 }
    let(:filler) do
      params = { total_questions: total_questions, section: section, passages: passages }
      described_class.new(params)
    end

    describe '.determine_number_of_passages' do
      describe 'static passage question range' do
        it 'returns at least 1 if range is greater than 1' do
          total_questions = 1
          range_number = 1
          value = filler.send(:determine_number_of_passages, total_questions, range_number)
          expect(value).to eq([1])
        end

        it 'returns at a ceilinged value' do
          total_questions = 3
          range_number = 2
          value = filler.send(:determine_number_of_passages, total_questions, range_number)
          expect(value).to eq([2])
        end
      end

      describe 'varied passage question range' do
        it 'returns an array' do
          total_questions = 15
          range_number = [5, 7]
          value = filler.send(:determine_number_of_passages, total_questions, range_number)
          expect(value).to be_kind_of Array
        end

        it 'returns a range of all values possible passage combination ranges' do
          total_questions = 15
          range_number = [5, 7]
          value = filler.send(:determine_number_of_passages, total_questions, range_number)
          expect(value).to match_array([3])
        end

        it 'returns a range of all values possible passage combination ranges where it\'s uneven' do
          total_questions = 15
          range_number = [3, 7]
          value = filler.send(:determine_number_of_passages, total_questions, range_number)
          expect(value).to match_array([3, 4, 5])
        end

        it 'returns a range like in science' do
          total_questions = 75
          range_number = [1, 3]
          value = filler.send(:determine_number_of_passages, total_questions, range_number)
          expect(value).to match_array((25..75).to_a)
        end
      end
    end

    describe '.passages & .question_set' do
      let(:filler) do
        params = { total_questions: total_questions,
                   section: section,
                   passages: passages_with_questions }
        described_class.new(params)
      end

      context 'english & reading' do
        # it's really 10 and 15, but they're even numbers, so.
        let(:english_and_reading_question_per_passage) { 15 }
        let(:total_questions) { 75 }
        let(:section) { create(:act_section, :english) }
        let(:passages_with_questions) do
          passage_types = create_list(:act_passage_type, 20, section: section)
          passages = create_list(:act_passage, 40,
                                 passage_type: passage_types.sample,
                                 section: section)
          passages.each do |passage|
            create_list(:act_question, 15, passage: passage, section: section)
          end
          Act::Passage.where(section_id: section.id)
        end

        it 'has at least correct number of questions' do
          passages = filler.passages.reduce(0) { |a, e| a + e.questions.size }
          expect(passages).to eq(total_questions)
        end
      end

      context 'science' do
        let(:total_questions) { 40 }
        let(:section) { create(:act_section, :science) }
        let(:passages_with_questions) do
          passage_types = create_list(:act_passage_type, 20, section: section)
          question_vals = [{ questions: 5, times: 20 },
                           { questions: 6, times: 40 },
                           { questions: 7, times: 40 }]
          question_vals.each do |d|
            passages = create_list(:act_passage,
                                   d[:times],
                                   passage_type: passage_types.sample,
                                   section: section)
            passages.each do |passage|
              create_list(:act_question, d[:questions], passage: passage, section: section)
            end
          end
          Act::Passage.where(section_id: section.id)
        end

        # this covers '%number_of_questions'
        it 'has the at least the number of questions' do
          passages = filler.passages.reduce(0) { |a, e| a + e.questions.size }
          expect(passages).to eq(total_questions)
        end
      end
    end

    context 'math' do
      let(:filler) do
        params = { total_questions: total_questions,
                   section: section,
                   passages: passages_with_questions }
        described_class.new(params)
      end
      let(:total_questions) { 60 }
      let(:section) { create(:act_section, :math) }
      let(:passages_with_questions) do
        create_list(:act_question, 150, :math, section: section)
        Act::Question.where(section_id: section.id)
      end

      it 'has the at least the number of questions' do
        passages = filler.passages.count
        expect(passages).to eq(total_questions)
      end
    end
  end
end