Rename ResponseRate to ResponseRateCalculator. Create a new response

rate model.  Create a loader to refresh response rates for all
subcategories.

Use precalculated response rates in views

Wrap more elements in page caching

Calculate a response rate for a subcategory if one does not already
exist

app/controllers/overview_controller.rb

@@ -16,13 +16,17 @@ class OverviewController < SqmApplicationController
   end
 
   def check_empty_dataset
-    @has_empty_dataset = measures.all? do |measure|
+    @has_empty_dataset = subcategories.all? do |subcategory|
-      measure.none_meet_threshold? school: @school, academic_year: @academic_year
+      response_rate = subcategory.response_rate(school: @school, academic_year: @academic_year)
+      !response_rate.meets_student_threshold && !response_rate.meets_teacher_threshold
     end
   end
 
   def measures
-    @measures ||= Measure.all.includes(%i[scales admin_data_items subcategory
+    @measures ||= Measure.all.includes(%i[scales admin_data_items category])
-                                          category]).includes(subcategory: :measures)
+  end
+
+  def subcategories
+    @subcategories ||= Subcategory.all
   end
 end

app/helpers/analyze_helper.rb

@@ -74,7 +74,8 @@ module AnalyzeHelper
   def empty_dataset?(measures:, school:, academic_year:)
     @empty_dataset ||= Hash.new do |memo, (school, academic_year)|
       memo[[school, academic_year]] = measures.all? do |measure|
-        measure.survey_item_responses.where(school:, academic_year:).none? || measure.none_meet_threshold?(school:, academic_year:)
+        response_rate = measure.subcategory.response_rate(school:, academic_year:)
+        !response_rate.meets_student_threshold && !response_rate.meets_teacher_threshold
       end
     end
 

app/models/measure.rb

@@ -202,35 +202,15 @@ class Measure < ActiveRecord::Base
     averages.average
   end
 
-  def student_survey_items_have_no_responses?(school:, academic_year:)
-    @student_survey_items_have_no_responses ||= Hash.new do |memo, (school, academic_year)|
-      memo[[school, academic_year]] = student_scales.all? do |scale|
-        scale.survey_item_responses.where(school:, academic_year:).none?
-      end
-    end
-    @student_survey_items_have_no_responses[[school, academic_year]]
-  end
-
-  def teacher_survey_items_have_no_responses?(school:, academic_year:)
-    @teacher_survey_items_have_no_responses ||= Hash.new do |memo, (school, academic_year)|
-      memo[[school, academic_year]] = teacher_scales.all? do |scale|
-        scale.survey_item_responses.where(school:, academic_year:).none?
-      end
-    end
-    @teacher_survey_items_have_no_responses[[school, academic_year]]
-  end
-
   def sufficient_student_data?(school:, academic_year:)
     return false unless includes_student_survey_items?
-    return false if student_survey_items_have_no_responses?(school:, academic_year:)
 
-    @sufficient_student_data ||= subcategory.student_response_rate(school:, academic_year:).meets_student_threshold?
+    @sufficient_student_data ||= subcategory.response_rate(school:, academic_year:).meets_student_threshold
   end
 
   def sufficient_teacher_data?(school:, academic_year:)
     return false unless includes_teacher_survey_items?
-    return false if teacher_survey_items_have_no_responses?(school:, academic_year:)
 
-    @sufficient_teacher_data ||= subcategory.teacher_response_rate(school:, academic_year:).meets_teacher_threshold?
+    @sufficient_teacher_data ||= subcategory.response_rate(school:, academic_year:).meets_teacher_threshold
   end
 end

app/models/response_rate_calculator.rb

@@ -1,6 +1,7 @@
 module ResponseRateCalculator
   TEACHER_RATE_THRESHOLD = 25
   STUDENT_RATE_THRESHOLD = 25
+  attr_reader :subcategory, :school, :academic_year
 
   def initialize(subcategory:, school:, academic_year:)
     @subcategory = subcategory
@@ -29,6 +30,8 @@ module ResponseRateCalculator
     rate >= TEACHER_RATE_THRESHOLD
   end
 
+  private
+
   def cap_at_100(response_rate)
     response_rate > 100 ? 100 : response_rate
   end

app/models/student_response_rate_calculator.rb

@@ -5,12 +5,13 @@ class StudentResponseRateCalculator
 
   def survey_item_count
     @survey_item_count ||= begin
-      survey = Survey.where(school: @school, academic_year: @academic_year).first
+      survey = Survey.find_by(school:, academic_year:)
+
       survey_items = SurveyItem.includes(%i[scale
                                             measure]).student_survey_items.where("scale.measure": @subcategory.measures)
       survey_items = survey_items.where(on_short_form: true) if survey.form == 'short'
       survey_items = survey_items.reject do |survey_item|
-        survey_item.survey_item_responses.where(school: @school, academic_year: @academic_year).none?
+        survey_item.survey_item_responses.where(school:, academic_year:).none?
       end
       survey_items.count
     end
@@ -19,40 +20,21 @@ class StudentResponseRateCalculator
   def response_count
     @response_count ||= @subcategory.measures.map do |measure|
       measure.student_survey_items.map do |survey_item|
-        survey_item.survey_item_responses.where(school: @school,
+        survey = Survey.find_by(school:, academic_year:)
-                                                academic_year: @academic_year).exclude_boston.count
+        next 0 if survey.form == 'short' && survey_item.on_short_form == false
+
+        survey_item.survey_item_responses.where(school:,
+                                                academic_year:).exclude_boston.count
       end.sum
     end.sum
   end
 
   def total_possible_responses
     @total_possible_responses ||= begin
-      total_responses = Respondent.where(school: @school, academic_year: @academic_year).first
+      total_responses = Respondent.find_by(school:, academic_year:)
       return 0 unless total_responses.present?
 
       total_responses.total_students
     end
   end
 end
-
-# survey = Survey.where(school:, academic_year:).first
-# total_possible_student_responses = Respondent.where(school:, academic_year:).first
-
-# student_survey_items = Subcategory.all.map do |subcategory|
-#   subcategory.measures.map do |measure|
-#     measure.student_scales.map do |scale|
-#       scale.survey_items.count
-#     end.sum
-#   end.sum
-# end
-# student_response_counts = Subcategory.all.map do |subcategory|
-#   subcategory.measures.map do |measure|
-#     measure.student_survey_items.map do |survey_item|
-#       survey_item.survey_item_responses.where(school:, academic_year:).exclude_boston.count
-#     end.sum
-#   end.sum
-# end
-
-# student_response_counts.each_with_index.map do |value, index|
-#   value.to_f / student_survey_items[index] / total_possible_student_responses * 100
-# end

app/models/subcategory.rb

@@ -4,26 +4,31 @@ class Subcategory < ActiveRecord::Base
   has_many :measures
 
   def score(school:, academic_year:)
-    scores = measures.includes([:survey_items]).map do |measure|
+    scores = measures.map do |measure|
       measure.score(school:, academic_year:).average
     end
     scores = scores.reject(&:nil?)
     scores.average
   end
 
-  def student_response_rate(school:, academic_year:)
+  def response_rate(school:, academic_year:)
-    @student_response_rate ||= Hash.new do |memo, (school, academic_year)|
+    @response_rate ||= Hash.new do |memo, (school, academic_year)|
-      memo[[school, academic_year]] = StudentResponseRateCalculator.new(subcategory: self, school:, academic_year:)
+      memo[[school, academic_year]] = ResponseRate.find_by(subcategory: self, school:, academic_year:)
     end
 
-    @student_response_rate[[school, academic_year]]
+    if @response_rate[[school, academic_year]].nil?
+      @response_rate[[school, academic_year]] = create_response_rate(subcategory: self, school:, academic_year:)
     end
 
-  def teacher_response_rate(school:, academic_year:)
+    @response_rate[[school, academic_year]]
-    @teacher_response_rate ||= Hash.new do |memo, (school, academic_year)|
-      memo[[school, academic_year]] = TeacherResponseRateCalculator.new(subcategory: self, school:, academic_year:)
   end
 
-    @teacher_response_rate[[school, academic_year]]
+  private
+
+  def create_response_rate(subcategory:, school:, academic_year:)
+    student = StudentResponseRateCalculator.new(subcategory: self, school:, academic_year:)
+    teacher = TeacherResponseRateCalculator.new(subcategory: self, school:, academic_year:)
+    ResponseRate.create(school:, academic_year:, subcategory: self, student_response_rate: student.rate, teacher_response_rate: teacher.rate,
+                        meets_student_threshold: student.meets_student_threshold?, meets_teacher_threshold: teacher.meets_teacher_threshold?)
   end
 end

app/models/survey_item_response.rb

@@ -5,6 +5,7 @@ class SurveyItemResponse < ActiveRecord::Base
   belongs_to :academic_year
   belongs_to :school
   belongs_to :survey_item
+  has_one :measure, through: :survey_item
 
   scope :exclude_boston, lambda {
                            boston = District.find_by_name('Boston')

app/presenters/subcategory_presenter.rb

@@ -32,13 +32,13 @@ class SubcategoryPresenter
   def student_response_rate
     return 'N / A' if Respondent.where(school: @school, academic_year: @academic_year).count.zero?
 
-    "#{@subcategory.student_response_rate(school: @school, academic_year: @academic_year).rate}%"
+    "#{@subcategory.response_rate(school: @school, academic_year: @academic_year).student_response_rate.to_i}%"
   end
 
   def teacher_response_rate
     return 'N / A' if Respondent.where(school: @school, academic_year: @academic_year).count.zero?
 
-    "#{@subcategory.teacher_response_rate(school: @school, academic_year: @academic_year).rate}%"
+    "#{@subcategory.response_rate(school: @school, academic_year: @academic_year).teacher_response_rate.to_i}%"
   end
 
   def admin_collection_rate

app/services/response_rate_loader.rb

@@ -0,0 +1,34 @@
+class ResponseRateLoader
+  def self.refresh
+    schools = School.all
+    academic_years = AcademicYear.all
+    subcategories = Subcategory.all
+
+    milford = School.find_by_slug 'milford-high-school'
+
+    # ResponseRate.new(school:, academic_year:, subcategory:, student_response_rate: 50, teacher_response_rate: 50,
+    #                  meets_student_threshold: true, meets_teacher_threshold: true).save
+
+    test_year = AcademicYear.find_by_range '2020-21'
+    subcategories.each do |subcategory|
+      schools.each do |school|
+        next if ENV['RAILS_ENV'] == 'test' && !(school == milford)
+
+        academic_years.each do |academic_year|
+          next if ENV['RAILS_ENV'] == 'test' && !(academic_year == test_year)
+
+          student = StudentResponseRateCalculator.new(subcategory:, school:, academic_year:)
+          teacher = TeacherResponseRateCalculator.new(subcategory:, school:, academic_year:)
+
+          response_rate = ResponseRate.find_or_create_by!(subcategory:, school:, academic_year:)
+
+          response_rate.student_response_rate = student.rate
+          response_rate.teacher_response_rate = teacher.rate
+          response_rate.meets_student_threshold = student.meets_student_threshold?
+          response_rate.meets_teacher_threshold = teacher.meets_teacher_threshold?
+          response_rate.save
+        end
+      end
+    end
+  end
+end

app/views/overview/index.html.erb

@@ -8,6 +8,7 @@
     </select>
 <% end  %>
 
+<% cache do   %>
   <svg class="d-none">
 
     <symbol viewBox="0 0 24 24" id="warning-harvey-ball">
@@ -62,6 +63,7 @@
       <circle cx="12" cy="12" r="11.5" />
     </symbol>
   </svg>
+<% end  %>
 
 <% cache [@school, @academic_year] do %>
   <div class="card">
@@ -97,9 +99,7 @@
 
     <%= render partial: "variance_chart", locals: { presenters: @variance_chart_row_presenters } , cached: true %>
   </div>
-<% end %>
 
-<% cache [@district, @school, @academic_year] do %>
   <% if @district == District.find_by_name("Boston")  %>
     <%= render partial: 'layouts/boston_modal' %>
   <% elsif @has_empty_dataset %>

lib/tasks/data.rake

@@ -42,6 +42,17 @@ namespace :data do
       SurveyResponsesDataLoader.load_data filepath:
     end
     puts "=====================> Completed loading #{SurveyItemResponse.count} survey responses"
+
+    puts 'Refreshing response rates'
+    ResponseRateLoader.refresh
+    puts "=====================> Completed loading #{ResponseRate.count} survey responses"
+  end
+
+  desc 'refresh response rate values'
+  task refresh_response_rates: :environment do
+    puts 'Refreshing response rates'
+    ResponseRateLoader.refresh
+    puts "=====================> Completed loading #{ResponseRate.count} survey responses"
   end
 
   desc 'load admin_data'

lib/tasks/one_off.rake

@@ -51,6 +51,9 @@ namespace :one_off do
     puts "=====================> Loading data from csv at path: #{filepath}"
     SurveyResponsesDataLoader.load_data filepath: filepath
     puts "=====================> Completed loading #{SurveyItemResponse.count} survey responses"
+    puts 'Refreshing response rates'
+    ResponseRateLoader.refresh
+    puts "=====================> Completed loading #{ResponseRate.count} survey responses"
   end
 
   desc 'load winchester results for 2021-22'
@@ -61,6 +64,9 @@ namespace :one_off do
       puts "=====================> Loading data from csv at path: #{filepath}"
       SurveyResponsesDataLoader.load_data filepath:
     end
+    puts 'Refreshing response rates'
+    ResponseRateLoader.refresh
+    puts "=====================> Completed loading #{ResponseRate.count} survey responses"
   end
 
   desc 'list scales that have no survey responses'

spec/models/response_rate_calculator_spec.rb

@@ -3,6 +3,9 @@ require 'rails_helper'
 describe ResponseRateCalculator, type: :model do
   let(:school) { create(:school) }
   let(:academic_year) { create(:academic_year) }
+  let(:survey) { create(:survey, school:, academic_year:) }
+  let(:short_form_survey) { create(:survey, form: :short, school:, academic_year:) }
+  let(:respondent) { create(:respondent, school:, academic_year:) }
 
   describe StudentResponseRateCalculator do
     let(:subcategory) { create(:subcategory) }
@@ -23,13 +26,14 @@ describe ResponseRateCalculator, type: :model do
       create_list(:survey_item_response, SurveyItemResponse::STUDENT_RESPONSE_THRESHOLD, survey_item: sufficient_student_survey_item_2,
                                                                                          academic_year:, school:, likert_score: 4)
     end
+
     context 'when a students take a regular survey' do
+      context 'when the average number of student responses per question in a subcategory is equal to the student response threshold' do
         before :each do
-        create(:respondent, school:, academic_year:)
+          respondent
-        create(:survey, school:, academic_year:)
+          survey
         end
 
-      context 'when the average number of student responses per question in a subcategory is equal to the student response threshold' do
         it 'returns a response rate equal to the response threshold' do
           expect(StudentResponseRateCalculator.new(subcategory:, school:,
                                                    academic_year:).rate).to eq 25
@@ -39,8 +43,8 @@ describe ResponseRateCalculator, type: :model do
 
     context 'when students take the short form survey' do
       before :each do
-        create(:respondent, school:, academic_year:)
+        respondent
-        create(:survey, form: :short, school:, academic_year:)
+        short_form_survey
       end
 
       context 'when the average number of student responses per question in a subcategory is equal to the student response threshold' do
@@ -49,19 +53,19 @@ describe ResponseRateCalculator, type: :model do
           sufficient_student_survey_item_2.update! on_short_form: true
         end
 
-        it 'returns 100 percent' do
+        it 'takes into account the responses from both survey items' do
           expect(StudentResponseRateCalculator.new(subcategory:, school:,
                                                    academic_year:).rate).to eq 25
         end
 
-        context 'for the same number of responses, if only one of the questions is a short form question, the response rate will be half' do
+        context 'and only one of the survey items is on the short form' do
           before do
             sufficient_student_survey_item_2.update! on_short_form: false
           end
 
-          it 'returns 100 percent' do
+          it 'the response rate ignores the responses in the non-short form item' do
             expect(StudentResponseRateCalculator.new(subcategory:, school:,
-                                                     academic_year:).rate).to eq 50
+                                                     academic_year:).rate).to eq 25
           end
         end
       end
@@ -69,8 +73,8 @@ describe ResponseRateCalculator, type: :model do
 
     context 'when the average number of teacher responses is greater than the total possible responses' do
       before do
-        create(:respondent, school:, academic_year:)
+        respondent
-        create(:survey, school:, academic_year:)
+        survey
         create_list(:survey_item_response, SurveyItemResponse::STUDENT_RESPONSE_THRESHOLD * 11, survey_item: sufficient_student_survey_item_2,
                                                                                                 academic_year:, school:, likert_score: 1)
       end
@@ -124,8 +128,8 @@ describe ResponseRateCalculator, type: :model do
 
     context 'when the average number of teacher responses per question in a subcategory is at the threshold' do
       before :each do
-        create(:respondent, school:, academic_year:)
+        respondent
-        create(:survey, school:, academic_year:)
+        survey
       end
       it 'returns 25 percent' do
         expect(TeacherResponseRateCalculator.new(subcategory:, school:,
@@ -135,8 +139,8 @@ describe ResponseRateCalculator, type: :model do
 
     context 'when the teacher response rate is not a whole number. eg 29.166%' do
       before do
-        create(:respondent, school:, academic_year:)
+        respondent
-        create(:survey, school:, academic_year:)
+        survey
         create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD + 1, survey_item: sufficient_teacher_survey_item_3,
                                                                                                academic_year:, school:, likert_score: 1)
       end
@@ -148,8 +152,8 @@ describe ResponseRateCalculator, type: :model do
 
     context 'when the average number of teacher responses is greater than the total possible responses' do
       before do
-        create(:respondent, school:, academic_year:)
+        respondent
-        create(:survey, school:, academic_year:)
+        survey
         create_list(:survey_item_response, SurveyItemResponse::TEACHER_RESPONSE_THRESHOLD * 11, survey_item: sufficient_teacher_survey_item_3,
                                                                                                 academic_year:, school:, likert_score: 1)
       end
@@ -169,8 +173,8 @@ describe ResponseRateCalculator, type: :model do
     context 'when there is an imbalance in the response rate of the teacher items' do
       context 'and one of the teacher items has no associated survey item responses' do
         before do
-          create(:respondent, school:, academic_year:)
+          respondent
-          create(:survey, school:, academic_year:)
+          survey
           insufficient_teacher_survey_item_4
         end
         it 'ignores the empty survey item and returns only the average response rate of teacher survey items with responses' do

spec/services/response_rate_loader_spec.rb

@@ -0,0 +1,140 @@
+require 'rails_helper'
+
+describe ResponseRateLoader do
+  let(:school) { School.find_by_slug 'milford-high-school' }
+  let(:academic_year) { AcademicYear.find_by_range '2020-21' }
+  let(:respondents) do
+    respondents = Respondent.where(school:, academic_year:).first
+    respondents.total_students = 10
+    respondents.total_teachers = 10
+    respondents.save
+  end
+
+  let(:short_form_survey) do
+    survey = Survey.find_by(school:, academic_year:)
+    survey.form = :short
+    survey.save
+    survey
+  end
+
+  let(:subcategory) { Subcategory.find_by_subcategory_id '5D' }
+
+  let(:s_acst_q1) { SurveyItem.find_by_survey_item_id 's-acst-q1' }
+  let(:s_acst_q2) { SurveyItem.find_by_survey_item_id 's-acst-q2' } # short form
+  let(:s_acst_q3) { SurveyItem.find_by_survey_item_id 's-acst-q3' }
+  let(:s_poaf_q1) { SurveyItem.find_by_survey_item_id 's-poaf-q1' }
+  let(:s_poaf_q2) { SurveyItem.find_by_survey_item_id 's-poaf-q2' }
+  let(:s_poaf_q3) { SurveyItem.find_by_survey_item_id 's-poaf-q3' } # short form
+  let(:s_poaf_q4) { SurveyItem.find_by_survey_item_id 's-poaf-q4' }
+  let(:t_phya_q2) { SurveyItem.find_by_survey_item_id 't-phya-q2' }
+  let(:t_phya_q3) { SurveyItem.find_by_survey_item_id 't-phya-q3' }
+
+  let(:s_acst) { Scale.find_by_scale_id 's-acst' }
+  let(:s_poaf) { Scale.find_by_scale_id 's-poaf' }
+  let(:t_phya) { Scale.find_by_scale_id 't-phya' }
+
+  let(:response_rate) { ResponseRate.find_by(subcategory:, school:, academic_year:) }
+
+  before :each do
+    Rails.application.load_seed
+    respondents
+  end
+
+  after :each do
+    DatabaseCleaner.clean
+  end
+
+  describe 'self.refresh' do
+    context 'When refreshing response rates' do
+      context 'and half the students responded to each question' do
+        before :each do
+          create_list(:survey_item_response, 5, survey_item: s_acst_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_acst_q2, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_acst_q3, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_poaf_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_poaf_q2, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_poaf_q3, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_poaf_q4, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: t_phya_q2, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: t_phya_q3, likert_score: 3, school:, academic_year:)
+
+          ResponseRateLoader.refresh
+        end
+
+        it 'populates the database with response rates' do
+          expect(s_acst_q1.survey_item_id).to eq 's-acst-q1'
+          expect(subcategory.subcategory_id).to eq '5D'
+          expect(subcategory.name).to eq 'Health'
+          expect(s_acst.score(school:, academic_year:)).to eq 3
+          expect(s_poaf.score(school:, academic_year:)).to eq 3
+          expect(t_phya.score(school:, academic_year:)).to eq 3
+          expect(response_rate.student_response_rate).to eq 50
+          expect(response_rate.teacher_response_rate).to eq 50
+          expect(response_rate.meets_student_threshold).to be true
+          expect(response_rate.meets_teacher_threshold).to be true
+        end
+        context 'when running the loader a second time' do
+          it 'is idempotent' do
+            response_count = ResponseRate.count
+            ResponseRateLoader.refresh
+            second_count = ResponseRate.count
+
+            expect(response_count).to eq second_count
+          end
+        end
+      end
+
+      context 'and only the first question for each scale was asked; e.g. like on a short form' do
+        before :each do
+          create_list(:survey_item_response, 5, survey_item: s_acst_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_poaf_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: t_phya_q2, likert_score: 3, school:, academic_year:)
+
+          ResponseRateLoader.refresh
+        end
+
+        it 'only takes into account the first question and ignores the other questions in the scale' do
+          expect(response_rate.student_response_rate).to eq 50
+          expect(response_rate.teacher_response_rate).to eq 50
+        end
+      end
+
+      context 'and no respondent entry exists for the school and year' do
+        before do
+          Respondent.destroy_all
+          create_list(:survey_item_response, 5, survey_item: s_acst_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: s_poaf_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 5, survey_item: t_phya_q2, likert_score: 3, school:, academic_year:)
+
+          ResponseRateLoader.refresh
+        end
+
+        it 'since no score can be calculated, it returns a default of 100' do
+          expect(response_rate.student_response_rate).to eq 100
+          expect(response_rate.teacher_response_rate).to eq 100
+        end
+      end
+
+      context 'and the school took the short form student survey' do
+        before :each do
+          create_list(:survey_item_response, 1, survey_item: s_acst_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 6, survey_item: s_acst_q2, likert_score: 3, school:, academic_year:) # short form
+          create_list(:survey_item_response, 1, survey_item: s_acst_q3, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 1, survey_item: s_poaf_q1, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 1, survey_item: s_poaf_q2, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 6, survey_item: s_poaf_q3, likert_score: 3, school:, academic_year:) # short form
+          create_list(:survey_item_response, 1, survey_item: s_poaf_q4, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 1, survey_item: t_phya_q2, likert_score: 3, school:, academic_year:)
+          create_list(:survey_item_response, 1, survey_item: t_phya_q3, likert_score: 3, school:, academic_year:)
+          short_form_survey
+
+          ResponseRateLoader.refresh
+        end
+
+        it 'only counts responses from survey items on the short form' do
+          expect(response_rate.student_response_rate).to eq 60
+        end
+      end
+    end
+  end
+end

spec/system/sqm_application_spec.rb

@@ -12,6 +12,7 @@ describe 'SQM Application' do
     driven_by :rack_test
     page.driver.browser.basic_authorize(username, password)
     create(:respondent, school:, academic_year:)
+    create(:survey, school:, academic_year:)
   end
 
   context 'when no measures meet their threshold' do

spec/views/analyze/index.html.erb_spec.rb

@@ -5,6 +5,8 @@ describe 'analyze/index' do
   subject { Nokogiri::HTML(rendered) }
   let(:category) { create(:category) }
   let(:subcategory) { create(:subcategory, category:) }
+  let(:school) { create(:school) }
+  let(:academic_year) { create(:academic_year) }
 
   let(:support_for_teaching) do
     measure = create(:measure, name: 'Support For Teaching Development & Growth', measure_id: '1A-I', subcategory:)
@@ -41,22 +43,20 @@ describe 'analyze/index' do
            ideal_low_benchmark: 4.5)
     measure
   end
-  let(:academic_year) { create(:academic_year) }
 
   before :each do
-    # assign :category_presenters, []
-    # assign :grouped_bar_column_presenters, grouped_bar_column_presenters
     assign :academic_year, academic_year
     assign :available_academic_years, [academic_year]
     assign :selected_academic_years, [academic_year]
-    # assign :academic_years, [academic_year]
     assign :district, create(:district)
-    assign :school, create(:school)
+    assign :school, school
     assign :category, category
     assign :categories, [category]
     assign :subcategory, subcategory
     assign :subcategories, category.subcategories
     assign :measures, [support_for_teaching, effective_leadership, professional_qualifications]
+    create(:respondent, school:, academic_year:)
+    create(:survey, school:, academic_year:)
 
     render
   end
@@ -107,7 +107,10 @@ describe 'analyze/index' do
     end
 
     it 'displays disabled checkboxes for years that dont have data' do
+      ResponseRateLoader.refresh
       year_checkbox = subject.css("##{academic_year.range}").first
+      expect(year_checkbox.name).to eq 'input'
+      expect(academic_year.range).to eq '2050-51'
       expect(year_checkbox).to have_attribute 'disabled'
     end
   end