update specs

Author: angyb00

app/controllers/reports/annual_reports_controller.rb

@@ -33,7 +33,8 @@ def recalculate
   end
 
   def range
-    year_start, year_end = range_params[:year_start], range_params[:year_end]
+    year_start = range_params[:year_start].to_i
+    year_end = range_params[:year_end].to_i
 
     if year_end < year_start
       flash[:error] = "End year must be greater than or equal to start year."

spec/requests/reports/annual_reports_requests_spec.rb

@@ -101,22 +101,19 @@
           expect(row_2017["New Field"]).to eq("42")
           expect(row_2017["Total Distributed"]).to eq("200")
         end
-
-        it "uses the earliest(smallest) year between year_start and organization's earliest_reporting_year" do
-          get range_reports_annual_reports_path(year_start: 2004, year_end: 2008, format: :csv)
-          # the organization was created in 2006 (created_at_2006)
-          # so the below years should not be in the output
-          expect(response.body).not_to include("2004")
-          expect(response.body).not_to include("2005")
-          response.body.split("\n")
-        end
       end
 
       context "invalid year ranges given" do
         it "should raise a URL error" do
           expect { get range_reports_annual_reports_path(year_start: 'test', year_end: 'test', format: :csv) }
             .to raise_error(ActionController::UrlGenerationError)
         end
+
+        it "should redirect and show an error message if end year is less than start year" do
+          get range_reports_annual_reports_path(year_start: 2018, year_end: 2016, format: :csv)
+          expect(response).to have_http_status(:found)
+          expect(flash[:error]).to eq("End year must be greater than or equal to start year.")
+        end
       end
     end
 

spec/services/reports/annual_survey_report_service_spec.rb

@@ -0,0 +1,85 @@
+RSpec.describe Reports::AnnualSurveyReportService, type: :service do
+  let(:organization) { create(:organization) }
+
+  subject(:service) do
+    described_class.new(organization: organization, year_start: year_start, year_end: year_end)
+  end
+
+  describe '#call' do
+    context "with a valid year range" do
+      let(:year_start) { 2020 }
+      let(:year_end) { 2022 }
+
+      let(:report_2020) { instance_double(AnnualReport) }
+      let(:report_2021) { instance_double(AnnualReport) }
+      let(:report_2022) { instance_double(AnnualReport) }
+
+      before do
+        allow(Reports).to receive(:retrieve_report)
+          .with(hash_including(year: 2020)).and_return(report_2020)
+        allow(Reports).to receive(:retrieve_report)
+          .with(hash_including(year: 2021)).and_return(report_2021)
+        allow(Reports).to receive(:retrieve_report)
+          .with(hash_including(year: 2022)).and_return(report_2022)
+      end
+
+      it "returns one report per year in the range" do
+        expect(service.call).to eq([report_2020, report_2021, report_2022])
+      end
+
+      it "calls retrieve_report with recalculate: true for each year" do
+        service.call
+        expect(Reports).to have_received(:retrieve_report)
+          .with(hash_including(organization: organization, year: 2020, recalculate: true))
+        expect(Reports).to have_received(:retrieve_report)
+          .with(hash_including(organization: organization, year: 2021, recalculate: true))
+        expect(Reports).to have_received(:retrieve_report)
+          .with(hash_including(organization: organization, year: 2022, recalculate: true))
+      end
+    end
+
+    context "with a single year range" do
+      let(:year_start) { 2021 }
+      let(:year_end) { 2021 }
+
+      let(:report_2021) { instance_double(AnnualReport) }
+
+      before do
+        allow(Reports).to receive(:retrieve_report)
+          .with(hash_including(year: 2021)).and_return(report_2021)
+      end
+
+      it "returns a single report" do
+        expect(service.call).to eq([report_2021])
+      end
+    end
+
+    context "when a year's report raises ActiveRecord::RecordInvalid" do
+      let(:year_start) { 2020 }
+      let(:year_end) { 2022 }
+
+      let(:report_2020) { instance_double(AnnualReport) }
+      let(:report_2022) { instance_double(AnnualReport) }
+
+      before do
+        allow(Reports).to receive(:retrieve_report)
+          .with(hash_including(year: 2020)).and_return(report_2020)
+        allow(Reports).to receive(:retrieve_report)
+          .with(hash_including(year: 2021)).and_raise(ActiveRecord::RecordInvalid)
+        allow(Reports).to receive(:retrieve_report)
+          .with(hash_including(year: 2022)).and_return(report_2022)
+      end
+
+      it "skips the failed year and returns the remaining reports" do
+        expect(service.call).to eq([report_2020, report_2022])
+      end
+
+      it "logs the error" do
+        allow(Rails.logger).to receive(:error)
+        service.call
+        expect(Rails.logger).to have_received(:error).with(/Failed to retrieve annual report for year 2021/)
+      end
+    end
+  end
+end
+