Cldc 1672 scheme reactivation (#1023)

* feat: add scheme reactivation behaviour

* test: add tests

* refactor: linting

* fix: find deactivation periods by scheme/location ids rather than just the first

* feat: add activating_soon status to location (not to schemes as they have no startdate field)

* feat: fix logic and add tests fo activating soon

* fix: check for startdate presence

app/controllers/locations_controller.rb

@@ -50,12 +50,12 @@ class LocationsController < ApplicationController
   end
 
   def new_reactivation
-    @location_deactivation_period = LocationDeactivationPeriod.deactivations_without_reactivation.first
+    @location_deactivation_period = @location.location_deactivation_periods.deactivations_without_reactivation.first
     render "toggle_active", locals: { action: "reactivate" }
   end
 
   def reactivate
-    @location_deactivation_period = LocationDeactivationPeriod.deactivations_without_reactivation.first
+    @location_deactivation_period = @location.location_deactivation_periods.deactivations_without_reactivation.first
 
     @location_deactivation_period.reactivation_date = toggle_date("reactivation_date")
     @location_deactivation_period.reactivation_date_type = params[:location_deactivation_period][:reactivation_date_type]

app/controllers/schemes_controller.rb

@@ -27,10 +27,10 @@ class SchemesController < ApplicationController
     if params[:scheme_deactivation_period].blank?
       render "toggle_active", locals: { action: "deactivate" }
     else
-      @scheme_deactivation_period.deactivation_date = deactivation_date
+      @scheme_deactivation_period.deactivation_date = toggle_date("deactivation_date")
       @scheme_deactivation_period.deactivation_date_type = params[:scheme_deactivation_period][:deactivation_date_type]
       @scheme_deactivation_period.scheme = @scheme
-      if @scheme_deactivation_period.validate
+      if @scheme_deactivation_period.valid?
         redirect_to scheme_deactivate_confirm_path(@scheme, deactivation_date: @scheme_deactivation_period.deactivation_date, deactivation_date_type: @scheme_deactivation_period.deactivation_date_type)
       else
         render "toggle_active", locals: { action: "deactivate" }, status: :unprocessable_entity
@@ -50,10 +50,25 @@ class SchemesController < ApplicationController
     redirect_to scheme_details_path(@scheme)
   end
 
-  def reactivate
+  def new_reactivation
+    @scheme_deactivation_period = @scheme.scheme_deactivation_periods.deactivations_without_reactivation.first
     render "toggle_active", locals: { action: "reactivate" }
   end
 
+  def reactivate
+    @scheme_deactivation_period = @scheme.scheme_deactivation_periods.deactivations_without_reactivation.first
+
+    @scheme_deactivation_period.reactivation_date = toggle_date("reactivation_date")
+    @scheme_deactivation_period.reactivation_date_type = params[:scheme_deactivation_period][:reactivation_date_type]
+
+    if @scheme_deactivation_period.update(reactivation_date: toggle_date("reactivation_date"))
+      flash[:notice] = reactivate_success_notice
+      redirect_to scheme_details_path(@scheme)
+    else
+      render "toggle_active", locals: { action: "reactivate" }, status: :unprocessable_entity
+    end
+  end
+
   def new
     @scheme = Scheme.new
   end
@@ -239,8 +254,7 @@ private
                                                      :support_type,
                                                      :arrangement_type,
                                                      :intended_stay,
-                                                     :confirmed,
+                                                     :confirmed)
-                                                     :deactivation_date)
 
     if arrangement_type_changed_to_different_org?(required_params)
       required_params[:managing_organisation_id] = nil
@@ -303,18 +317,27 @@ private
     end
   end
 
-  def deactivation_date
+  def reactivate_success_notice
+    case @scheme.status
+    when :active
+      "#{@scheme.service_name} has been reactivated"
+    when :reactivating_soon
+      "#{@scheme.service_name} will reactivate on #{toggle_date('reactivation_date').to_time.to_formatted_s(:govuk_date)}"
+    end
+  end
+
+  def toggle_date(key)
     if params[:scheme_deactivation_period].blank?
       return
-    elsif params[:scheme_deactivation_period][:deactivation_date_type] == "default"
+    elsif params[:scheme_deactivation_period]["#{key}_type".to_sym] == "default"
       return FormHandler.instance.current_collection_start_date
-    elsif params[:scheme_deactivation_period][:deactivation_date].present?
+    elsif params[:scheme_deactivation_period][key.to_sym].present?
-      return params[:scheme_deactivation_period][:deactivation_date]
+      return params[:scheme_deactivation_period][key.to_sym]
     end
 
-    day = params[:scheme_deactivation_period]["deactivation_date(3i)"]
+    day = params[:scheme_deactivation_period]["#{key}(3i)"]
-    month = params[:scheme_deactivation_period]["deactivation_date(2i)"]
+    month = params[:scheme_deactivation_period]["#{key}(2i)"]
-    year = params[:scheme_deactivation_period]["deactivation_date(1i)"]
+    year = params[:scheme_deactivation_period]["#{key}(1i)"]
     return nil if [day, month, year].any?(&:blank?)
 
     Time.zone.local(year.to_i, month.to_i, day.to_i) if Date.valid_date?(year.to_i, month.to_i, day.to_i)

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

app/helpers/schemes_helper.rb

@@ -28,11 +28,43 @@ module SchemesHelper
   end
 
   def scheme_availability(scheme)
-    availability = "Active from #{scheme.available_from.to_formatted_s(:govuk_date)}"
+    availability = ""
-    scheme.scheme_deactivation_periods.each do |deactivation|
+    scheme_active_periods(scheme).each do |period|
-      availability << " to #{(deactivation.deactivation_date - 1.day).to_formatted_s(:govuk_date)}\nDeactivated on #{deactivation.deactivation_date.to_formatted_s(:govuk_date)}"
+      if period.from.present?
-      availability << "\nActive from #{deactivation.reactivation_date.to_formatted_s(:govuk_date)}" if deactivation.reactivation_date.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?
+      end
     end
-    availability
+    availability.strip
+  end
+
+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
+
+  def remove_nested_periods(periods)
+    periods.select { |inner_period| periods.none? { |outer_period| is_nested?(inner_period, outer_period) } }
+  end
+
+  def is_nested?(inner, outer)
+    return false if inner == outer
+    return false if [inner.deactivation_date, inner.reactivation_date, outer.deactivation_date, outer.reactivation_date].any?(&:blank?)
+
+    [inner.deactivation_date, inner.reactivation_date].all? { |date| date.between?(outer.deactivation_date, outer.reactivation_date) }
   end
 end

app/helpers/tag_helper.rb

@@ -9,6 +9,7 @@ module TagHelper
     active: "Active",
     incomplete: "Incomplete",
     deactivating_soon: "Deactivating soon",
+    activating_soon: "Activating soon",
     reactivating_soon: "Reactivating soon",
     deactivated: "Deactivated",
   }.freeze
@@ -21,6 +22,7 @@ module TagHelper
     active: "green",
     incomplete: "red",
     deactivating_soon: "yellow",
+    activating_soon: "blue",
     reactivating_soon: "blue",
     deactivated: "grey",
   }.freeze

app/helpers/toggle_active_scheme_helper.rb

@@ -0,0 +1,17 @@
+module ToggleActiveSchemeHelper
+  def toggle_scheme_form_path(action, scheme)
+    if action == "deactivate"
+      scheme_new_deactivation_path(scheme)
+    else
+      scheme_reactivate_path(scheme)
+    end
+  end
+
+  def date_type_question(action)
+    action == "deactivate" ? :deactivation_date_type : :reactivation_date_type
+  end
+
+  def date_question(action)
+    action == "deactivate" ? :deactivation_date : :reactivation_date
+  end
+end

app/models/location.rb

@@ -380,6 +380,7 @@ class Location < ApplicationRecord
     return :deactivated if open_deactivation&.deactivation_date.present? && Time.zone.now >= open_deactivation.deactivation_date
     return :deactivating_soon if open_deactivation&.deactivation_date.present? && Time.zone.now < open_deactivation.deactivation_date
     return :reactivating_soon if recent_deactivation&.reactivation_date.present? && Time.zone.now < recent_deactivation.reactivation_date
+    return :activating_soon if startdate.present? && Time.zone.now < startdate
 
     :active
   end

app/models/scheme.rb

@@ -210,18 +210,25 @@ class Scheme < ApplicationRecord
   end
 
   def available_from
-    created_at
+    [created_at, FormHandler.instance.current_collection_start_date].min
   end
 
   def status
-    recent_deactivation = scheme_deactivation_periods.deactivations_without_reactivation.first
+    open_deactivation = scheme_deactivation_periods.deactivations_without_reactivation.first
-    return :active if recent_deactivation.blank?
+    recent_deactivation = scheme_deactivation_periods.order("created_at").last
-    return :deactivating_soon if Time.zone.now < recent_deactivation.deactivation_date
 
-    :deactivated
+    return :deactivated if open_deactivation&.deactivation_date.present? && Time.zone.now >= open_deactivation.deactivation_date
+    return :deactivating_soon if open_deactivation&.deactivation_date.present? && Time.zone.now < open_deactivation.deactivation_date
+    return :reactivating_soon if recent_deactivation&.reactivation_date.present? && Time.zone.now < recent_deactivation.reactivation_date
+
+    :active
   end
 
   def active?
     status == :active
   end
+
+  def reactivating_soon?
+    status == :reactivating_soon
+  end
 end

app/models/scheme_deactivation_period.rb

@@ -1,15 +1,40 @@
 class SchemeDeactivationPeriodValidator < ActiveModel::Validator
   def validate(record)
+    scheme = record.scheme
+    recent_deactivation = scheme.scheme_deactivation_periods.deactivations_without_reactivation.first
+    if recent_deactivation.present?
+      validate_reactivation(record, recent_deactivation, scheme)
+    else
+      validate_deactivation(record, scheme)
+    end
+  end
+
+  def validate_reactivation(record, recent_deactivation, scheme)
+    if record.reactivation_date.blank?
+      if record.reactivation_date_type.blank?
+        record.errors.add(:reactivation_date_type, message: I18n.t("validations.scheme.toggle_date.not_selected"))
+      elsif record.reactivation_date_type == "other"
+        record.errors.add(:reactivation_date, message: I18n.t("validations.scheme.toggle_date.invalid"))
+      end
+    elsif !record.reactivation_date.between?(scheme.available_from, Time.zone.local(2200, 1, 1))
+      record.errors.add(:reactivation_date, message: I18n.t("validations.scheme.toggle_date.out_of_range", date: scheme.available_from.to_formatted_s(:govuk_date)))
+    elsif record.reactivation_date < recent_deactivation.deactivation_date
+      record.errors.add(:reactivation_date, message: I18n.t("validations.scheme.reactivation.before_deactivation", date: recent_deactivation.deactivation_date.to_formatted_s(:govuk_date)))
+    end
+  end
+
+  def validate_deactivation(record, scheme)
     if record.deactivation_date.blank?
       if record.deactivation_date_type.blank?
-        record.errors.add(:deactivation_date_type, message: I18n.t("validations.scheme.deactivation_date.not_selected"))
+        record.errors.add(:deactivation_date_type, message: I18n.t("validations.scheme.toggle_date.not_selected"))
       elsif record.deactivation_date_type == "other"
-        record.errors.add(:deactivation_date, message: I18n.t("validations.scheme.deactivation_date.invalid"))
+        record.errors.add(:deactivation_date, message: I18n.t("validations.scheme.toggle_date.invalid"))
       end
+    elsif scheme.scheme_deactivation_periods.any? { |period| period.reactivation_date.present? && record.deactivation_date.between?(period.deactivation_date, period.reactivation_date - 1.day) }
+      record.errors.add(:deactivation_date, message: I18n.t("validations.scheme.deactivation.during_deactivated_period"))
     else
-      collection_start_date = FormHandler.instance.current_collection_start_date
+      unless record.deactivation_date.between?(scheme.available_from, Time.zone.local(2200, 1, 1))
-      unless record.deactivation_date.between?(collection_start_date, Time.zone.local(2200, 1, 1))
+        record.errors.add(:deactivation_date, message: I18n.t("validations.scheme.toggle_date.out_of_range", date: scheme.available_from.to_formatted_s(:govuk_date)))
-        record.errors.add(:deactivation_date, message: I18n.t("validations.scheme.deactivation_date.out_of_range", date: collection_start_date.to_formatted_s(:govuk_date)))
       end
     end
   end

app/views/schemes/deactivate_confirm.html.erb

@@ -1,5 +1,3 @@
-<% title = "Deactivate #{@scheme.service_name}" %>
-<% content_for :title, title %>
 <%= form_with model: @scheme_deactivation_period, url: scheme_deactivate_path(@scheme), method: "patch", local: true do |f| %>
   <% content_for :before_content do %>
     <%= govuk_back_link(href: :back) %>
@@ -8,7 +6,7 @@
     <span class="govuk-caption-l"><%= @scheme.service_name %></span>
     This change will affect <%= @scheme.lettings_logs.count %> logs
   </h1>
-  <%= govuk_warning_text text: I18n.t("warnings.scheme.deactivation.review_logs") %>
+  <%= govuk_warning_text text: I18n.t("warnings.scheme.deactivate.review_logs") %>
   <%= f.hidden_field :confirm, value: true %>
   <%= f.hidden_field :deactivation_date, value: @deactivation_date %>
   <%= f.hidden_field :deactivation_date_type, value: @deactivation_date_type %>

app/views/schemes/show.html.erb

@@ -26,9 +26,9 @@
 <% end %>
 
 <% if FeatureToggle.scheme_toggle_enabled? %>
-  <% if @scheme.active? %>
+  <% if @scheme.active? || @scheme.reactivating_soon? %>
     <%= govuk_button_link_to "Deactivate this scheme", scheme_new_deactivation_path(@scheme), warning: true %>
   <% else %>
-    <%= govuk_button_link_to "Reactivate this scheme", scheme_reactivate_path(@scheme) %>
+    <%= govuk_button_link_to "Reactivate this scheme", scheme_new_reactivation_path(@scheme) %>
   <% end %>
 <% end %>

app/views/schemes/toggle_active.html.erb

@@ -1,29 +1,31 @@
 <% title = "#{action.humanize} #{@scheme.service_name}" %>
 <% content_for :title, title %>
+
 <% content_for :before_content do %>
   <%= govuk_back_link(
         text: "Back",
         href: scheme_details_path(@scheme),
       ) %>
 <% end %>
-<%= form_with model: @scheme_deactivation_period, url: scheme_new_deactivation_path(@scheme), method: "patch", local: true do |f| %>
+
+<%= form_with model: @scheme_deactivation_period, url: toggle_scheme_form_path(action, @scheme), method: "patch", local: true do |f| %>
   <div class="govuk-grid-row">
     <div class="govuk-grid-column-two-thirds">
       <% collection_start_date = FormHandler.instance.current_collection_start_date %>
       <%= f.govuk_error_summary %>
-      <%= f.govuk_radio_buttons_fieldset :deactivation_date_type,
+      <%= f.govuk_radio_buttons_fieldset date_type_question(action),
-                                         legend: { text: I18n.t("questions.scheme.deactivation.apply_from") },
+                                         legend: { text: I18n.t("questions.scheme.toggle_active.apply_from") },
                                          caption: { text: title },
-                                         hint: { text: I18n.t("hints.scheme.deactivation", date: collection_start_date.to_formatted_s(:govuk_date)) } do %>
+                                         hint: { text: I18n.t("hints.scheme.toggle_active", date: collection_start_date.to_formatted_s(:govuk_date)) } do %>
-        <%= govuk_warning_text text: I18n.t("warnings.scheme.deactivation.existing_logs") %>
+        <%= govuk_warning_text text: I18n.t("warnings.scheme.#{action}.existing_logs") %>
-        <%= f.govuk_radio_button :deactivation_date_type,
+        <%= f.govuk_radio_button date_type_question(action),
                                  "default",
                                  label: { text: "From the start of the current collection period (#{collection_start_date.to_formatted_s(:govuk_date)})" } %>
-        <%= f.govuk_radio_button :deactivation_date_type,
+        <%= f.govuk_radio_button date_type_question(action),
                                  "other",
                                  label: { text: "For tenancies starting after a certain date" },
                                  **basic_conditional_html_attributes({ "deactivation_date" => %w[other] }, "scheme") do %>
-          <%= f.govuk_date_field :deactivation_date,
+          <%= f.govuk_date_field date_question(action),
                                  legend: { text: "Date", size: "m" },
                                  hint: { text: "For example, 27 3 2022" },
                                  width: 20 %>

config/locales/en.yml

@@ -313,10 +313,16 @@ en:
       missing: "You must show the DLUHC privacy notice to the tenant before you can submit this log."
 
     scheme:
-      deactivation_date:
+      toggle_date:
         not_selected: "Select one of the options"
         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}. 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"
+
+
 
     location:
       toggle_date:
@@ -324,8 +330,8 @@ 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: 
+      deactivation:
         during_deactivated_period: "The location is already deactivated during this date, please enter a different date"
 
   soft_validations:
@@ -381,7 +387,7 @@ en:
       toggle_active:
         apply_from: "When should this change apply?"
     scheme:
-      deactivation:
+      toggle_active:
         apply_from: "When should this change apply?"
     descriptions:
       location:
@@ -397,19 +403,21 @@ en:
       units: "A unit can be a bedroom in a shared house or flat, or a house with 4 bedrooms. Do not include bedrooms used for wardens, managers, volunteers or sleep-in staff."
       toggle_active: "If the date is before %{date}, select ‘From the start of the current collection period’ because the previous period has now closed."
     scheme:
-      deactivation: "If the date is before %{date}, select ‘From the start of the current collection period’ because the previous period has now closed."
+      toggle_active: "If the date is before %{date}, select ‘From the start of the current collection period’ because the previous period has now closed."
 
   warnings:
     location:
       deactivate:
         existing_logs: "It will not be possible to add logs with this location if their tenancy start date is on or after the date you enter. Any existing logs may be affected."
         review_logs: "Your data providers will need to review these logs and answer a few questions again. We’ll email each log creator with a list of logs that need updating."
-      reactivate: 
+      reactivate:
         existing_logs: "You’ll be able to add logs with this location if their tenancy start date is on or after the date you enter."
     scheme:
-      deactivation:
+      deactivate:
         existing_logs: "It will not be possible to add logs with this scheme if their tenancy start date is on or after the date you enter. Any existing logs may be affected."
         review_logs: "Your data providers will need to review these logs and answer a few questions again. We’ll email each log creator with a list of logs that need updating."
+      reactivate:
+        existing_logs: "You’ll be able to add logs with this scheme if their tenancy start date is on or after the date you enter."
 
   test:
     one_argument: "This is based on the tenant’s work situation: %{ecstat1}"

config/routes.rb

@@ -52,8 +52,10 @@ Rails.application.routes.draw do
     get "new-deactivation", to: "schemes#new_deactivation"
     get "deactivate-confirm", to: "schemes#deactivate_confirm"
     get "reactivate", to: "schemes#reactivate"
+    get "new-reactivation", to: "schemes#new_reactivation"
     patch "new-deactivation", to: "schemes#new_deactivation"
     patch "deactivate", to: "schemes#deactivate"
+    patch "reactivate", to: "schemes#reactivate"
 
     resources :locations do
       get "edit-name", to: "locations#edit_name"

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

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(location_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).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(location_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).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(location_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(location_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).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(location_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(location_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).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).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(location_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(location_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).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(location_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(location_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).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).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(location_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(location_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).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(location_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(location_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).second).to have_attributes(from: Time.zone.local(2022, 7, 7), to: nil)
     end
   end
 

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, 10, 10), reactivation_date: Time.zone.local(2022, 12, 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, 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

spec/models/location_spec.rb

@@ -151,6 +151,12 @@ RSpec.describe Location, type: :model do
         location.save!
         expect(location.status).to eq(:reactivating_soon)
       end
+
+      it "returns activating soon if the location has a future startdate" do
+        location.startdate = Time.zone.local(2022, 7, 7)
+        location.save!
+        expect(location.status).to eq(:activating_soon)
+      end
     end
 
     context "when there have been previous deactivations" do
@@ -188,12 +194,18 @@ RSpec.describe Location, type: :model do
         expect(location.status).to eq(:reactivating_soon)
       end
 
-      it "returns if the location had a deactivation during another deactivation" do
+      it "returns reactivating soon if the location had a deactivation during another deactivation" do
         Timecop.freeze(2022, 6, 4)
         FactoryBot.create(:location_deactivation_period, deactivation_date: Time.zone.local(2022, 5, 5), reactivation_date: Time.zone.local(2022, 6, 2), location:)
         location.save!
         expect(location.status).to eq(:reactivating_soon)
       end
+
+      it "returns activating soon if the location has a future startdate" do
+        location.startdate = Time.zone.local(2022, 7, 7)
+        location.save!
+        expect(location.status).to eq(:activating_soon)
+      end
     end
   end
 end

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

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