From 299116eff9ef8754fa14e0b9e7856bb55e305c71 Mon Sep 17 00:00:00 2001 From: natdeanlewissoftwire Date: Wed, 23 Nov 2022 12:52:48 +0000 Subject: [PATCH] test: add tests --- app/helpers/locations_helper.rb | 28 +-- app/helpers/schemes_helper.rb | 28 +-- config/locales/en.yml | 4 +- spec/factories/scheme_deactivation_period.rb | 1 + spec/helpers/locations_helper_spec.rb | 48 ++--- spec/helpers/schemes_helper_spec.rb | 182 ++++++++++++++++++- spec/models/scheme_spec.rb | 20 ++ spec/requests/schemes_controller_spec.rb | 17 +- 8 files changed, 259 insertions(+), 69 deletions(-) diff --git a/app/helpers/locations_helper.rb b/app/helpers/locations_helper.rb index ca04826ba..8d56226a9 100644 --- a/app/helpers/locations_helper.rb +++ b/app/helpers/locations_helper.rb @@ -42,22 +42,9 @@ module LocationsHelper base_attributes end - ActivePeriod = Struct.new(:from, :to) - def active_periods(location) - periods = [ActivePeriod.new(location.available_from, nil)] - - sorted_deactivation_periods = remove_nested_periods(location.location_deactivation_periods.sort_by(&:deactivation_date)) - sorted_deactivation_periods.each do |deactivation| - periods.last.to = deactivation.deactivation_date - periods << ActivePeriod.new(deactivation.reactivation_date, nil) - end - - remove_overlapping_and_empty_periods(periods) - end - def location_availability(location) availability = "" - active_periods(location).each do |period| + location_active_periods(location).each do |period| if period.from.present? availability << "\nActive from #{period.from.to_formatted_s(:govuk_date)}" availability << " to #{(period.to - 1.day).to_formatted_s(:govuk_date)}\nDeactivated on #{period.to.to_formatted_s(:govuk_date)}" if period.to.present? @@ -68,6 +55,19 @@ module LocationsHelper private + ActivePeriod = Struct.new(:from, :to) + def location_active_periods(location) + periods = [ActivePeriod.new(location.available_from, nil)] + + sorted_deactivation_periods = remove_nested_periods(location.location_deactivation_periods.sort_by(&:deactivation_date)) + sorted_deactivation_periods.each do |deactivation| + periods.last.to = deactivation.deactivation_date + periods << ActivePeriod.new(deactivation.reactivation_date, nil) + end + + remove_overlapping_and_empty_periods(periods) + end + def remove_overlapping_and_empty_periods(periods) periods.select { |period| period.from.present? && (period.to.nil? || period.from < period.to) } end diff --git a/app/helpers/schemes_helper.rb b/app/helpers/schemes_helper.rb index 6a10806bb..def40db7b 100644 --- a/app/helpers/schemes_helper.rb +++ b/app/helpers/schemes_helper.rb @@ -27,22 +27,9 @@ module SchemesHelper base_attributes end - ActivePeriod = Struct.new(:from, :to) - def active_periods(scheme) - periods = [ActivePeriod.new(scheme.available_from, nil)] - - sorted_deactivation_periods = remove_nested_periods(scheme.scheme_deactivation_periods.sort_by(&:deactivation_date)) - sorted_deactivation_periods.each do |deactivation| - periods.last.to = deactivation.deactivation_date - periods << ActivePeriod.new(deactivation.reactivation_date, nil) - end - - remove_overlapping_and_empty_periods(periods) - end - def scheme_availability(scheme) availability = "" - active_periods(scheme).each do |period| + scheme_active_periods(scheme).each do |period| if period.from.present? availability << "\nActive from #{period.from.to_formatted_s(:govuk_date)}" availability << " to #{(period.to - 1.day).to_formatted_s(:govuk_date)}\nDeactivated on #{period.to.to_formatted_s(:govuk_date)}" if period.to.present? @@ -53,6 +40,19 @@ module SchemesHelper private + ActivePeriod = Struct.new(:from, :to) + def scheme_active_periods(scheme) + periods = [ActivePeriod.new(scheme.available_from, nil)] + + sorted_deactivation_periods = remove_nested_periods(scheme.scheme_deactivation_periods.sort_by(&:deactivation_date)) + sorted_deactivation_periods.each do |deactivation| + periods.last.to = deactivation.deactivation_date + periods << ActivePeriod.new(deactivation.reactivation_date, nil) + end + + remove_overlapping_and_empty_periods(periods) + end + def remove_overlapping_and_empty_periods(periods) periods.select { |period| period.from.present? && (period.to.nil? || period.from < period.to) } end diff --git a/config/locales/en.yml b/config/locales/en.yml index 697c412fd..5a8843e46 100644 --- a/config/locales/en.yml +++ b/config/locales/en.yml @@ -318,7 +318,7 @@ en: invalid: "Enter a valid day, month and year" out_of_range: "The date must be on or after the %{date}" reactivation: - before_deactivation: "This scheme was deactivated on %{date}\nThe reactivation date must be on or after deactivation date" + before_deactivation: "This scheme was deactivated on %{date}. The reactivation date must be on or after deactivation date" deactivation: during_deactivated_period: "The scheme is already deactivated during this date, please enter a different date" @@ -330,7 +330,7 @@ en: invalid: "Enter a valid day, month and year" out_of_range: "The date must be on or after the %{date}" reactivation: - before_deactivation: "This location was deactivated on %{date}\nThe reactivation date must be on or after deactivation date" + before_deactivation: "This location was deactivated on %{date}. The reactivation date must be on or after deactivation date" deactivation: during_deactivated_period: "The location is already deactivated during this date, please enter a different date" diff --git a/spec/factories/scheme_deactivation_period.rb b/spec/factories/scheme_deactivation_period.rb index c073bc68a..95e33d9ce 100644 --- a/spec/factories/scheme_deactivation_period.rb +++ b/spec/factories/scheme_deactivation_period.rb @@ -1,5 +1,6 @@ FactoryBot.define do factory :scheme_deactivation_period do + deactivation_date { Time.zone.local(2022, 4, 1) } reactivation_date { nil } end end diff --git a/spec/helpers/locations_helper_spec.rb b/spec/helpers/locations_helper_spec.rb index bccacba3c..4d9340542 100644 --- a/spec/helpers/locations_helper_spec.rb +++ b/spec/helpers/locations_helper_spec.rb @@ -59,8 +59,8 @@ RSpec.describe LocationsHelper do end it "returns one active period without to date" do - expect(active_periods(location).count).to eq(1) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: nil) + expect(location_active_periods(location).count).to eq(1) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: nil) end it "ignores reactivations that were deactivated on the same day" do @@ -68,8 +68,8 @@ RSpec.describe LocationsHelper do FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 6, 4), location:) location.reload - expect(active_periods(location).count).to eq(1) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(location_active_periods(location).count).to eq(1) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) end it "returns sequential non reactivated active periods" do @@ -77,19 +77,19 @@ RSpec.describe LocationsHelper do FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 7, 6), location:) location.reload - expect(active_periods(location).count).to eq(2) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) - expect(active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) + expect(location_active_periods(location).count).to eq(2) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(location_active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) end it "returns sequential reactivated active periods" do FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 4), location:) FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 7, 6), reactivation_date: Time.zone.local(2022, 8, 5), location:) location.reload - expect(active_periods(location).count).to eq(3) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) - expect(active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) - expect(active_periods(location).third).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) + expect(location_active_periods(location).count).to eq(3) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(location_active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) + expect(location_active_periods(location).third).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) end it "returns non sequential non reactivated active periods" do @@ -97,19 +97,19 @@ RSpec.describe LocationsHelper do FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: nil, location:) location.reload - expect(active_periods(location).count).to eq(2) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) - expect(active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) + expect(location_active_periods(location).count).to eq(2) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(location_active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) end it "returns non sequential reactivated active periods" do FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 7, 6), reactivation_date: Time.zone.local(2022, 8, 5), location:) FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 4), location:) location.reload - expect(active_periods(location).count).to eq(3) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) - expect(active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) - expect(active_periods(location).third).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) + expect(location_active_periods(location).count).to eq(3) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(location_active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) + expect(location_active_periods(location).third).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) end it "returns correct active periods when reactivation happends during a deactivated period" do @@ -117,9 +117,9 @@ RSpec.describe LocationsHelper do FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 4, 6), reactivation_date: Time.zone.local(2022, 7, 7), location:) location.reload - expect(active_periods(location).count).to eq(2) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 4, 6)) - expect(active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 11, 11), to: nil) + expect(location_active_periods(location).count).to eq(2) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 4, 6)) + expect(location_active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 11, 11), to: nil) end it "returns correct active periods when a full deactivation period happens during another deactivation period" do @@ -127,9 +127,9 @@ RSpec.describe LocationsHelper do FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 4, 6), reactivation_date: Time.zone.local(2022, 7, 7), location:) location.reload - expect(active_periods(location).count).to eq(2) - expect(active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 4, 6)) - expect(active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 7, 7), to: nil) + expect(location_active_periods(location).count).to eq(2) + expect(location_active_periods(location).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 4, 6)) + expect(location_active_periods(location).second).to have_attributes(from: Time.zone.local(2022, 7, 7), to: nil) end end diff --git a/spec/helpers/schemes_helper_spec.rb b/spec/helpers/schemes_helper_spec.rb index 9db3639d9..96f472457 100644 --- a/spec/helpers/schemes_helper_spec.rb +++ b/spec/helpers/schemes_helper_spec.rb @@ -1,8 +1,94 @@ require "rails_helper" RSpec.describe SchemesHelper do + describe "Active periods" do + let(:scheme) { FactoryBot.create(:scheme) } + + before do + Timecop.freeze(2022, 10, 10) + end + + after do + Timecop.unfreeze + end + + it "returns one active period without to date" do + expect(scheme_active_periods(scheme).count).to eq(1) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: nil) + end + + it "ignores reactivations that were deactivated on the same day" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 4), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 6, 4), scheme:) + scheme.reload + + expect(scheme_active_periods(scheme).count).to eq(1) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + end + + it "returns sequential non reactivated active periods" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 4), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 7, 6), scheme:) + scheme.reload + + expect(scheme_active_periods(scheme).count).to eq(2) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(scheme_active_periods(scheme).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) + end + + it "returns sequential reactivated active periods" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 4), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 7, 6), reactivation_date: Time.zone.local(2022, 8, 5), scheme:) + scheme.reload + expect(scheme_active_periods(scheme).count).to eq(3) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(scheme_active_periods(scheme).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) + expect(scheme_active_periods(scheme).third).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) + end + + it "returns non sequential non reactivated active periods" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 7, 6), reactivation_date: Time.zone.local(2022, 8, 5), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: nil, scheme:) + scheme.reload + + expect(scheme_active_periods(scheme).count).to eq(2) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(scheme_active_periods(scheme).second).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) + end + + it "returns non sequential reactivated active periods" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 7, 6), reactivation_date: Time.zone.local(2022, 8, 5), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 4), scheme:) + scheme.reload + expect(scheme_active_periods(scheme).count).to eq(3) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 5, 5)) + expect(scheme_active_periods(scheme).second).to have_attributes(from: Time.zone.local(2022, 6, 4), to: Time.zone.local(2022, 7, 6)) + expect(scheme_active_periods(scheme).third).to have_attributes(from: Time.zone.local(2022, 8, 5), to: nil) + end + + it "returns correct active periods when reactivation happends during a deactivated period" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 11, 11), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 4, 6), reactivation_date: Time.zone.local(2022, 7, 7), scheme:) + scheme.reload + + expect(scheme_active_periods(scheme).count).to eq(2) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 4, 6)) + expect(scheme_active_periods(scheme).second).to have_attributes(from: Time.zone.local(2022, 11, 11), to: nil) + end + + it "returns correct active periods when a full deactivation period happens during another deactivation period" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 11), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 4, 6), reactivation_date: Time.zone.local(2022, 7, 7), scheme:) + scheme.reload + + expect(scheme_active_periods(scheme).count).to eq(2) + expect(scheme_active_periods(scheme).first).to have_attributes(from: Time.zone.local(2022, 4, 1), to: Time.zone.local(2022, 4, 6)) + expect(scheme_active_periods(scheme).second).to have_attributes(from: Time.zone.local(2022, 7, 7), to: nil) + end + end + describe "display_scheme_attributes" do - let!(:scheme) { FactoryBot.create(:scheme, created_at: Time.zone.local(2022, 8, 8)) } + let!(:scheme) { FactoryBot.create(:scheme, created_at: Time.zone.local(2022, 4, 1)) } it "returns correct display attributes" do attributes = [ @@ -18,32 +104,116 @@ RSpec.describe SchemesHelper do { name: "Secondary client group", value: scheme.secondary_client_group }, { name: "Level of support given", value: scheme.support_type }, { name: "Intended length of stay", value: scheme.intended_stay }, - { name: "Availability", value: "Active from 8 August 2022" }, + { name: "Availability", value: "Active from 1 April 2022" }, { name: "Status", value: :active }, ] expect(display_scheme_attributes(scheme)).to eq(attributes) end context "when viewing availability" do - context "with are no deactivations" do + context "with no deactivations" do it "displays created_at as availability date" do availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] expect(availability_attribute).to eq("Active from #{scheme.created_at.to_formatted_s(:govuk_date)}") end + + it "displays current collection start date as availability date if created_at is later than collection start date" do + scheme.update!(created_at: Time.zone.local(2022, 4, 16)) + availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] + + expect(availability_attribute).to eq("Active from 1 April 2022") + end end context "with previous deactivations" do + context "and all reactivated deactivations" do + before do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 8, 10), reactivation_date: Time.zone.local(2022, 9, 1), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 9, 15), reactivation_date: Time.zone.local(2022, 9, 28), scheme:) + scheme.reload + end + + it "displays the timeline of availability" do + availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] + + expect(availability_attribute).to eq("Active from 1 April 2022 to 9 August 2022\nDeactivated on 10 August 2022\nActive from 1 September 2022 to 14 September 2022\nDeactivated on 15 September 2022\nActive from 28 September 2022") + end + end + + context "and non reactivated deactivation" do + before do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 8, 10), reactivation_date: Time.zone.local(2022, 9, 1), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 9, 15), reactivation_date: nil, scheme:) + scheme.reload + end + + it "displays the timeline of availability" do + availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] + + expect(availability_attribute).to eq("Active from 1 April 2022 to 9 August 2022\nDeactivated on 10 August 2022\nActive from 1 September 2022 to 14 September 2022\nDeactivated on 15 September 2022") + end + end + end + + context "with out of order deactivations" do + context "and all reactivated deactivations" do + before do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 9, 24), reactivation_date: Time.zone.local(2022, 9, 28), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 6, 15), reactivation_date: Time.zone.local(2022, 6, 18), scheme:) + scheme.reload + end + + it "displays the timeline of availability" do + availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] + + expect(availability_attribute).to eq("Active from 1 April 2022 to 14 June 2022\nDeactivated on 15 June 2022\nActive from 18 June 2022 to 23 September 2022\nDeactivated on 24 September 2022\nActive from 28 September 2022") + end + end + + context "and one non reactivated deactivation" do + before do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 9, 24), reactivation_date: Time.zone.local(2022, 9, 28), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 6, 15), reactivation_date: nil, scheme:) + scheme.reload + end + + it "displays the timeline of availability" do + availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] + + expect(availability_attribute).to eq("Active from 1 April 2022 to 14 June 2022\nDeactivated on 15 June 2022\nActive from 28 September 2022") + end + end + end + + context "with multiple out of order deactivations" do + context "and one non reactivated deactivation" do + before do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 9, 24), reactivation_date: Time.zone.local(2022, 9, 28), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 10, 24), reactivation_date: Time.zone.local(2022, 10, 28), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 6, 15), reactivation_date: nil, scheme:) + scheme.reload + end + + it "displays the timeline of availability" do + availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] + + expect(availability_attribute).to eq("Active from 1 April 2022 to 14 June 2022\nDeactivated on 15 June 2022\nActive from 28 September 2022 to 23 October 2022\nDeactivated on 24 October 2022\nActive from 28 October 2022") + end + end + end + + context "with intersecting deactivations" do before do - FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 8, 10), reactivation_date: Time.zone.local(2022, 9, 1), scheme:) - FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 9, 15), reactivation_date: nil, scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 10, 10), reactivation_date: Time.zone.local(2022, 12, 1), scheme:) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 11, 11), reactivation_date: Time.zone.local(2022, 12, 11), scheme:) scheme.reload end it "displays the timeline of availability" do availability_attribute = display_scheme_attributes(scheme).find { |x| x[:name] == "Availability" }[:value] - expect(availability_attribute).to eq("Active from 8 August 2022 to 9 August 2022\nDeactivated on 10 August 2022\nActive from 1 September 2022 to 14 September 2022\nDeactivated on 15 September 2022") + expect(availability_attribute).to eq("Active from 1 April 2022 to 9 October 2022\nDeactivated on 10 October 2022\nActive from 11 December 2022") end end end diff --git a/spec/models/scheme_spec.rb b/spec/models/scheme_spec.rb index b19e8c992..58d0a8da8 100644 --- a/spec/models/scheme_spec.rb +++ b/spec/models/scheme_spec.rb @@ -125,6 +125,12 @@ RSpec.describe Scheme, type: :model do scheme.reload expect(scheme.status).to eq(:deactivated) end + + it "returns reactivating soon if the location has a future reactivation date" do + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 6, 7), reactivation_date: Time.zone.local(2022, 6, 8), scheme:) + scheme.save! + expect(scheme.status).to eq(:reactivating_soon) + end end context "when there have been previous deactivations" do @@ -153,6 +159,20 @@ RSpec.describe Scheme, type: :model do scheme.reload expect(scheme.status).to eq(:deactivated) end + + it "returns reactivating soon if the scheme has a future reactivation date" do + Timecop.freeze(2022, 6, 8) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 6, 7), reactivation_date: Time.zone.local(2022, 6, 9), scheme:) + scheme.save! + expect(scheme.status).to eq(:reactivating_soon) + end + + it "returns if the scheme had a deactivation during another deactivation" do + Timecop.freeze(2022, 6, 4) + FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 2), scheme:) + scheme.save! + expect(scheme.status).to eq(:reactivating_soon) + end end end end diff --git a/spec/requests/schemes_controller_spec.rb b/spec/requests/schemes_controller_spec.rb index 0c3b47f1a..ee9cca533 100644 --- a/spec/requests/schemes_controller_spec.rb +++ b/spec/requests/schemes_controller_spec.rb @@ -274,7 +274,7 @@ RSpec.describe SchemesController, type: :request do it "renders reactivate this scheme" do expect(response).to have_http_status(:ok) - expect(page).to have_link("Reactivate this scheme", href: "/schemes/#{scheme.id}/reactivate") + expect(page).to have_link("Reactivate this scheme", href: "/schemes/#{scheme.id}/new-reactivation") end end @@ -283,7 +283,7 @@ RSpec.describe SchemesController, type: :request do it "renders reactivate this scheme" do expect(response).to have_http_status(:ok) - expect(page).to have_link("Reactivate this scheme", href: "/schemes/#{scheme.id}/reactivate") + expect(page).to have_link("Reactivate this scheme", href: "/schemes/#{scheme.id}/new-reactivation") end end end @@ -915,7 +915,6 @@ RSpec.describe SchemesController, type: :request do context "when signed in as a support" do let(:user) { FactoryBot.create(:user, :support) } let(:scheme_to_update) { FactoryBot.create(:scheme, owning_organisation: user.organisation, confirmed: nil) } - # let!(:location) { FactoryBot.create(:location, scheme: scheme_to_update) } before do FactoryBot.create(:location, scheme: scheme_to_update) @@ -1855,7 +1854,7 @@ RSpec.describe SchemesController, type: :request do it "displays the new page with an error message" do expect(response).to have_http_status(:unprocessable_entity) - expect(page).to have_content(I18n.t("validations.scheme.deactivation_date.not_selected")) + expect(page).to have_content(I18n.t("validations.scheme.toggle_date.not_selected")) end end @@ -1864,7 +1863,7 @@ RSpec.describe SchemesController, type: :request do it "displays the new page with an error message" do expect(response).to have_http_status(:unprocessable_entity) - expect(page).to have_content(I18n.t("validations.scheme.deactivation_date.invalid")) + expect(page).to have_content(I18n.t("validations.scheme.toggle_date.invalid")) end end @@ -1873,7 +1872,7 @@ RSpec.describe SchemesController, type: :request do it "displays the new page with an error message" do expect(response).to have_http_status(:unprocessable_entity) - expect(page).to have_content(I18n.t("validations.scheme.deactivation_date.out_of_range", date: "1 April 2022")) + expect(page).to have_content(I18n.t("validations.scheme.toggle_date.out_of_range", date: "1 April 2022")) end end @@ -1882,7 +1881,7 @@ RSpec.describe SchemesController, type: :request do it "displays page with an error message" do expect(response).to have_http_status(:unprocessable_entity) - expect(page).to have_content(I18n.t("validations.scheme.deactivation_date.invalid")) + expect(page).to have_content(I18n.t("validations.scheme.toggle_date.invalid")) end end @@ -1891,7 +1890,7 @@ RSpec.describe SchemesController, type: :request do it "displays page with an error message" do expect(response).to have_http_status(:unprocessable_entity) - expect(page).to have_content(I18n.t("validations.scheme.deactivation_date.invalid")) + expect(page).to have_content(I18n.t("validations.scheme.toggle_date.invalid")) end end @@ -1900,7 +1899,7 @@ RSpec.describe SchemesController, type: :request do it "displays page with an error message" do expect(response).to have_http_status(:unprocessable_entity) - expect(page).to have_content(I18n.t("validations.scheme.deactivation_date.invalid")) + expect(page).to have_content(I18n.t("validations.scheme.toggle_date.invalid")) end end end