From 99e5c53136dfdce78508650f2044856965463cc8 Mon Sep 17 00:00:00 2001
From: Samuel Young <samuel.young@softwire.com>
Date: Wed, 6 Aug 2025 10:07:03 +0100
Subject: [PATCH] CLDC-4074: Fix model tests

---
 spec/models/log_spec.rb                       |   6 +-
 spec/models/scheme_spec.rb                    |   2 +-
 .../validations/date_validations_spec.rb      |   4 +-
 .../validations/household_validations_spec.rb | 164 ----
 .../sales/financial_validations_spec.rb       | 343 ++++----
 .../sales/household_validations_spec.rb       | 389 +++------
 .../sales/property_validations_spec.rb        |  75 +-
 .../sale_information_validations_spec.rb      | 793 ++++++++----------
 .../sales/soft_validations_spec.rb            |  93 +-
 9 files changed, 606 insertions(+), 1263 deletions(-)

diff --git a/spec/models/log_spec.rb b/spec/models/log_spec.rb
index bccfb0e2e..572fbe078 100644
--- a/spec/models/log_spec.rb
+++ b/spec/models/log_spec.rb
@@ -1,6 +1,8 @@
 require "rails_helper"
 
 RSpec.describe Log, type: :model do
+  include CollectionTimeHelper
+
   it "has two child log classes" do
     expect(SalesLog).to be < described_class
     expect(LettingsLog).to be < described_class
@@ -62,12 +64,12 @@ RSpec.describe Log, type: :model do
     end
 
     context "when a non setup field is invalid for a lettings log" do
-      subject(:model) { build_stubbed(:lettings_log, :completed, startdate: Time.zone.local(2023, 12, 12), offered: 234) }
+      subject(:model) { build_stubbed(:lettings_log, :completed, startdate: current_collection_start_date, age1: 234) }
 
       it "blanks it" do
         model.valid?
         model.blank_invalid_non_setup_fields!
-        expect(model.offered).to be_nil
+        expect(model.age1).to be_nil
       end
     end
 
diff --git a/spec/models/scheme_spec.rb b/spec/models/scheme_spec.rb
index c13247a53..d51aabb61 100644
--- a/spec/models/scheme_spec.rb
+++ b/spec/models/scheme_spec.rb
@@ -472,7 +472,7 @@ RSpec.describe Scheme, type: :model do
 
       context "when the most recently created deactivation is not the current one" do
         before do
-          FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.today - 300.days, reactivation_date: Time.zone.today - 200.days, scheme:)
+          FactoryBot.create(:scheme_deactivation_period, deactivation_date: Time.zone.today - 5.days, reactivation_date: Time.zone.today - 4.days, scheme:)
         end
 
         it "returns reactivating_soon" do
diff --git a/spec/models/validations/date_validations_spec.rb b/spec/models/validations/date_validations_spec.rb
index b88a75eb2..626093e89 100644
--- a/spec/models/validations/date_validations_spec.rb
+++ b/spec/models/validations/date_validations_spec.rb
@@ -56,7 +56,7 @@ RSpec.describe Validations::DateValidations do
 
     context "with 2024 logs or earlier" do
       it "cannot be more than 10 years before the tenancy start date" do
-        record.startdate = Time.zone.local(2024, 2, 1)
+        record.startdate = Time.zone.local(2024, 4, 1)
         record.mrcdate = Time.zone.local(2014, 1, 31)
         date_validator.validate_property_major_repairs(record)
         expect(record.errors["mrcdate"])
@@ -150,7 +150,7 @@ RSpec.describe Validations::DateValidations do
 
     context "with 2024 logs or earlier" do
       it "cannot be more than 10 years before the tenancy start date" do
-        record.startdate = Time.zone.local(2024, 2, 1)
+        record.startdate = Time.zone.local(2024, 4, 1)
         record.voiddate = Time.zone.local(2014, 1, 31)
         date_validator.validate_property_void_date(record)
         expect(record.errors["voiddate"])
diff --git a/spec/models/validations/household_validations_spec.rb b/spec/models/validations/household_validations_spec.rb
index 3bad55f9b..f4e706bb8 100644
--- a/spec/models/validations/household_validations_spec.rb
+++ b/spec/models/validations/household_validations_spec.rb
@@ -50,17 +50,6 @@ RSpec.describe Validations::HouseholdValidations do
         expect(record.errors["reasonother"]).to be_empty
       end
 
-      context "when form year is before 2024" do
-        let(:startdate) { Time.zone.local(2024, 1, 1) }
-
-        it "does not validate the content of reasonother for phrases indicating homelessness" do
-          record.reason = 20
-          record.reasonother = "Temp accommodation"
-          household_validator.validate_reason_for_leaving_last_settled_home(record)
-          expect(record.errors["reason"]).to be_empty
-        end
-      end
-
       context "when form year is >= 2024" do
         let(:startdate) { Time.zone.local(2024, 4, 1) }
 
@@ -273,53 +262,7 @@ RSpec.describe Validations::HouseholdValidations do
     end
   end
 
-  describe "#validate_partner_count" do
-    let(:startdate) { Time.zone.local(2023, 4, 1) }
-
-    it "validates that only 1 partner exists" do
-      record.relat2 = "P"
-      record.relat3 = "P"
-      household_validator.validate_partner_count(record)
-      expect(record.errors["relat2"])
-        .to include(match I18n.t("validations.lettings.household.relat.one_partner"))
-      expect(record.errors["relat3"])
-        .to include(match I18n.t("validations.lettings.household.relat.one_partner"))
-      expect(record.errors["relat4"])
-        .not_to include(match I18n.t("validations.lettings.household.relat.one_partner"))
-    end
-
-    it "expects that a tenant can have a partner" do
-      record.relat3 = "P"
-      household_validator.validate_partner_count(record)
-      expect(record.errors["base"]).to be_empty
-    end
-  end
-
   describe "#validate_person_age_matches_relationship" do
-    context "with 2023 logs" do
-      let(:startdate) { Time.zone.local(2023, 4, 1) }
-
-      context "when the household contains a person under 16" do
-        it "validates that person must be a child of the tenant" do
-          record.age2 = 14
-          record.relat2 = "P"
-          household_validator.validate_person_age_matches_relationship(record)
-          expect(record.errors["relat2"])
-            .to include(match I18n.t("validations.lettings.household.relat.child_under_16", person_num: 2))
-          expect(record.errors["age2"])
-            .to include(match I18n.t("validations.lettings.household.age.child_under_16_relat", person_num: 2))
-        end
-
-        it "expects that person is a child of the tenant" do
-          record.age2 = 14
-          record.relat2 = "C"
-          household_validator.validate_person_age_matches_relationship(record)
-          expect(record.errors["relat2"]).to be_empty
-          expect(record.errors["age2"]).to be_empty
-        end
-      end
-    end
-
     context "with 2024 logs" do
       let(:startdate) { Time.zone.local(2024, 4, 1) }
 
@@ -342,41 +285,6 @@ RSpec.describe Validations::HouseholdValidations do
   end
 
   describe "#validate_person_age_matches_economic_status" do
-    context "with 2023 logs" do
-      let(:startdate) { Time.zone.local(2023, 4, 1) }
-
-      context "when the household contains a person under 16" do
-        it "validates that person's economic status must be Child" do
-          record.age2 = 14
-          record.ecstat2 = 1
-          household_validator.validate_person_age_matches_economic_status(record)
-          expect(record.errors["ecstat2"])
-            .to include(match I18n.t("validations.lettings.household.ecstat.child_under_16", person_num: 2))
-          expect(record.errors["age2"])
-            .to include(match I18n.t("validations.lettings.household.age.child_under_16_ecstat", person_num: 2))
-        end
-
-        it "expects that person's economic status is Child" do
-          record.age2 = 14
-          record.ecstat2 = 9
-          household_validator.validate_person_age_matches_economic_status(record)
-          expect(record.errors["ecstat2"]).to be_empty
-          expect(record.errors["age2"]).to be_empty
-        end
-
-        it "validates that a person with economic status 'child' must be under 16" do
-          record.age2 = 21
-          record.relat2 = "C"
-          record.ecstat2 = 9
-          household_validator.validate_person_age_matches_economic_status(record)
-          expect(record.errors["ecstat2"])
-            .to include(match I18n.t("validations.lettings.household.ecstat.child_over_16", person_num: 2))
-          expect(record.errors["age2"])
-            .to include(match I18n.t("validations.lettings.household.age.child_over_16", person_num: 2))
-        end
-      end
-    end
-
     context "with 2024 logs" do
       let(:startdate) { Time.zone.local(2024, 4, 1) }
 
@@ -393,78 +301,6 @@ RSpec.describe Validations::HouseholdValidations do
   end
 
   describe "#validate_person_age_and_relationship_matches_economic_status" do
-    context "with 2023 logs" do
-      let(:startdate) { Time.zone.local(2023, 4, 1) }
-
-      context "when the household contains a tenant’s child between the ages of 16 and 19" do
-        it "validates that person's economic status must be full time student or refused" do
-          record.age2 = 17
-          record.relat2 = "C"
-          record.ecstat2 = 1
-          household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-          expect(record.errors["ecstat2"])
-            .to include(match I18n.t("validations.lettings.household.ecstat.student_16_19.must_be_student", person_num: 2))
-          expect(record.errors["age2"])
-            .to include(match I18n.t("validations.lettings.household.age.student_16_19.cannot_be_16_19.child_not_student", person_num: 2))
-          expect(record.errors["relat2"])
-            .to include(match I18n.t("validations.lettings.household.relat.student_16_19.cannot_be_child.16_19_not_student", person_num: 2))
-        end
-
-        it "expects that person can be a full time student" do
-          record.age2 = 17
-          record.relat2 = "C"
-          record.ecstat2 = 7
-          household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-          expect(record.errors["ecstat2"]).to be_empty
-          expect(record.errors["age2"]).to be_empty
-          expect(record.errors["relat2"]).to be_empty
-        end
-
-        it "expects that person can refuse to share their work status" do
-          record.age2 = 17
-          record.relat2 = "C"
-          record.ecstat2 = 10
-          household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-          expect(record.errors["ecstat2"]).to be_empty
-          expect(record.errors["age2"]).to be_empty
-          expect(record.errors["relat2"]).to be_empty
-        end
-      end
-
-      it "does not add an error for a person aged 16-19 who is a student but not a child of the lead tenant" do
-        record.age2 = 18
-        record.ecstat2 = "7"
-        record.relat2 = "P"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "does not add an error for a person not aged 16-19 who is a student but not a child of the lead tenant" do
-        record.age2 = 20
-        record.ecstat2 = "7"
-        record.relat2 = "P"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "adds errors for a person who is a child of the lead tenant and a student but not aged 16-19" do
-        record.age2 = 14
-        record.ecstat2 = "7"
-        record.relat2 = "C"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"])
-          .to include(match I18n.t("validations.lettings.household.relat.student_16_19.cannot_be_child.student_not_16_19"))
-        expect(record.errors["age2"])
-          .to include(match I18n.t("validations.lettings.household.age.student_16_19.must_be_16_19"))
-        expect(record.errors["ecstat2"])
-          .to include(match I18n.t("validations.lettings.household.ecstat.student_16_19.cannot_be_student.child_not_16_19"))
-      end
-    end
-
     context "with 2024 logs" do
       let(:startdate) { Time.zone.local(2024, 4, 1) }
 
diff --git a/spec/models/validations/sales/financial_validations_spec.rb b/spec/models/validations/sales/financial_validations_spec.rb
index e6f1a2958..80d10718b 100644
--- a/spec/models/validations/sales/financial_validations_spec.rb
+++ b/spec/models/validations/sales/financial_validations_spec.rb
@@ -1,6 +1,8 @@
 require "rails_helper"
 
 RSpec.describe Validations::Sales::FinancialValidations do
+  include CollectionTimeHelper
+
   subject(:financial_validator) { validator_class.new }
 
   let(:validator_class) { Class.new { include Validations::Sales::FinancialValidations } }
@@ -208,47 +210,28 @@ RSpec.describe Validations::Sales::FinancialValidations do
   end
 
   describe "#validate_percentage_bought_not_equal_percentage_owned" do
-    let(:record) { FactoryBot.build(:sales_log) }
-
-    context "with 24/25 logs" do
-      before do
-        record.saledate = Time.zone.local(2024, 4, 3)
-      end
-
-      it "does not add an error if the percentage bought is less than the percentage owned" do
-        record.stairbought = 20
-        record.stairowned = 40
-        financial_validator.validate_percentage_bought_not_equal_percentage_owned(record)
-        expect(record.errors).to be_empty
-      end
-
-      it "adds an error if the percentage bought is equal to the percentage owned" do
-        record.stairbought = 30
-        record.stairowned = 30
-        financial_validator.validate_percentage_bought_not_equal_percentage_owned(record)
-        expect(record.errors["stairowned"]).to eq([I18n.t("validations.sales.financial.stairowned.percentage_bought_equal_percentage_owned", stairbought: 30, stairowned: 30)])
-        expect(record.errors["stairbought"]).to eq([I18n.t("validations.sales.financial.stairbought.percentage_bought_equal_percentage_owned", stairbought: 30, stairowned: 30)])
-      end
+    let(:record) { FactoryBot.build(:sales_log, :saledate_today) }
 
-      it "does not add an error to stairowned and not stairbought if the percentage bought is more than the percentage owned" do
-        record.stairbought = 50
-        record.stairowned = 40
-        financial_validator.validate_percentage_bought_not_equal_percentage_owned(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add an error if the percentage bought is less than the percentage owned" do
+      record.stairbought = 20
+      record.stairowned = 40
+      financial_validator.validate_percentage_bought_not_equal_percentage_owned(record)
+      expect(record.errors).to be_empty
     end
 
-    context "with 23/24 logs" do
-      before do
-        record.saledate = Time.zone.local(2023, 4, 3)
-      end
+    it "adds an error if the percentage bought is equal to the percentage owned" do
+      record.stairbought = 30
+      record.stairowned = 30
+      financial_validator.validate_percentage_bought_not_equal_percentage_owned(record)
+      expect(record.errors["stairowned"]).to eq([I18n.t("validations.sales.financial.stairowned.percentage_bought_equal_percentage_owned", stairbought: 30, stairowned: 30)])
+      expect(record.errors["stairbought"]).to eq([I18n.t("validations.sales.financial.stairbought.percentage_bought_equal_percentage_owned", stairbought: 30, stairowned: 30)])
+    end
 
-      it "does not add an error if the percentage bought is equal to the percentage owned" do
-        record.stairbought = 30
-        record.stairowned = 30
-        financial_validator.validate_percentage_bought_not_equal_percentage_owned(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add an error to stairowned and not stairbought if the percentage bought is more than the percentage owned" do
+      record.stairbought = 50
+      record.stairowned = 40
+      financial_validator.validate_percentage_bought_not_equal_percentage_owned(record)
+      expect(record.errors).to be_empty
     end
   end
 
@@ -348,195 +331,151 @@ RSpec.describe Validations::Sales::FinancialValidations do
   describe "#validate_equity_in_range_for_year_and_type" do
     let(:record) { FactoryBot.build(:sales_log, saledate:, resale: nil) }
 
-    context "with a log in the 22/23 collection year" do
-      let(:saledate) { Time.zone.local(2023, 1, 1) }
-
-      it "adds an error for type 2, equity below min with the correct percentage" do
-        record.type = 2
-        record.equity = 1
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_under_min", min_equity: 25))
-        expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_under_min", min_equity: 25))
-      end
-
-      it "adds an error for type 30, equity below min with the correct percentage" do
-        record.type = 30
-        record.equity = 1
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_under_min", min_equity: 10))
-        expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_under_min", min_equity: 10))
-      end
-
-      it "does not add an error for equity in range with the correct percentage" do
-        record.type = 2
-        record.equity = 50
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors).to be_empty
-      end
-
-      it "adds an error for equity above max with the correct percentage" do
-        record.type = 2
-        record.equity = 90
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_over_max", max_equity: 75))
-        expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_over_max", max_equity: 75))
-      end
+    let(:saledate) { current_collection_start_date }
 
-      it "does not add an error if it's a resale" do
-        record.type = 2
-        record.equity = 90
-        record.resale = 1
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors).to be_empty
-      end
+    it "adds an error for type 2, equity below min with the correct percentage" do
+      record.type = 2
+      record.equity = 1
+      financial_validator.validate_equity_in_range_for_year_and_type(record)
+      expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_under_min", min_equity: 25))
+      expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_under_min", min_equity: 25))
     end
 
-    context "with a log in 23/24 collection year" do
-      let(:saledate) { Time.zone.local(2024, 1, 1) }
+    it "adds an error for type 30, equity below min with the correct percentage" do
+      record.type = 30
+      record.equity = 1
+      financial_validator.validate_equity_in_range_for_year_and_type(record)
+      expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_under_min", min_equity: 10))
+      expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_under_min", min_equity: 10))
+    end
 
-      it "adds an error for type 2, equity below min with the correct percentage" do
-        record.type = 2
-        record.equity = 1
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_under_min", min_equity: 25))
-        expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_under_min", min_equity: 25))
-      end
+    it "adds an error for type 18, low equity below min with the correct percentage" do
+      record.type = 18
+      record.equity = 10
+      financial_validator.validate_equity_in_range_for_year_and_type(record)
+      expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_under_min", min_equity: 25))
+      expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_under_min", min_equity: 25))
+    end
 
-      it "adds an error for type 30, equity below min with the correct percentage" do
-        record.type = 30
-        record.equity = 1
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_under_min", min_equity: 10))
-        expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_under_min", min_equity: 10))
-      end
+    it "does not add an error for type 30, low equity in range with the correct percentage" do
+      record.type = 30
+      record.equity = 10
+      financial_validator.validate_equity_in_range_for_year_and_type(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "does not add an error for equity in range with the correct percentage" do
-        record.type = 2
-        record.equity = 50
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add an error for equity in range with the correct percentage" do
+      record.type = 2
+      record.equity = 50
+      financial_validator.validate_equity_in_range_for_year_and_type(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "adds an error for equity above max with the correct percentage" do
-        record.type = 2
-        record.equity = 90
-        financial_validator.validate_equity_in_range_for_year_and_type(record)
-        expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_over_max", max_equity: 75))
-        expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_over_max", max_equity: 75))
-      end
+    it "adds an error for equity above max with the correct percentage" do
+      record.type = 2
+      record.equity = 90
+      financial_validator.validate_equity_in_range_for_year_and_type(record)
+      expect(record.errors["equity"]).to include(match I18n.t("validations.sales.financial.equity.equity_over_max", max_equity: 75))
+      expect(record.errors["type"]).to include(match I18n.t("validations.sales.financial.type.equity_over_max", max_equity: 75))
     end
   end
 
   describe "#validate_staircase_difference" do
     let(:record) { FactoryBot.build(:sales_log, saledate:) }
 
-    context "with a log in the 23/24 collection year" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
+    let(:saledate) { current_collection_start_date }
 
-      it "does not add an error" do
-        record.stairbought = 2
-        record.stairowned = 3
-        record.equity = 2
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "adds errors if equity is more than stairowned - stairbought for joint purchase" do
+      record.stairbought = 2.5
+      record.stairowned = 3
+      record.equity = 2
+      record.jointpur = 1
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors["equity"]).to include(I18n.t("validations.sales.financial.equity.equity_over_stairowned_minus_stairbought.joint_purchase", equity: 2, staircase_difference: 0.5))
+      expect(record.errors["stairowned"]).to include(I18n.t("validations.sales.financial.stairowned.equity_over_stairowned_minus_stairbought.joint_purchase", equity: 2, staircase_difference: 0.5))
+      expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.financial.stairbought.equity_over_stairowned_minus_stairbought.joint_purchase", equity: 2, staircase_difference: 0.5))
     end
 
-    context "with a log in 24/25 collection year" do
-      let(:saledate) { Time.zone.local(2024, 4, 1) }
-
-      it "adds errors if equity is more than stairowned - stairbought for joint purchase" do
-        record.stairbought = 2.5
-        record.stairowned = 3
-        record.equity = 2
-        record.jointpur = 1
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors["equity"]).to include(I18n.t("validations.sales.financial.equity.equity_over_stairowned_minus_stairbought.joint_purchase", equity: 2, staircase_difference: 0.5))
-        expect(record.errors["stairowned"]).to include(I18n.t("validations.sales.financial.stairowned.equity_over_stairowned_minus_stairbought.joint_purchase", equity: 2, staircase_difference: 0.5))
-        expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.financial.stairbought.equity_over_stairowned_minus_stairbought.joint_purchase", equity: 2, staircase_difference: 0.5))
-      end
-
-      it "adds errors if equity is more than stairowned - stairbought for non joint purchase" do
-        record.stairbought = 2
-        record.stairowned = 3
-        record.equity = 2.5
-        record.jointpur = 2
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors["equity"]).to include(I18n.t("validations.sales.financial.equity.equity_over_stairowned_minus_stairbought.not_joint_purchase", equity: 2.5, staircase_difference: 1.0))
-        expect(record.errors["stairowned"]).to include(I18n.t("validations.sales.financial.stairowned.equity_over_stairowned_minus_stairbought.not_joint_purchase", equity: 2.5, staircase_difference: 1.0))
-        expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.financial.stairbought.equity_over_stairowned_minus_stairbought.not_joint_purchase", equity: 2.5, staircase_difference: 1.0))
-      end
+    it "adds errors if equity is more than stairowned - stairbought for non joint purchase" do
+      record.stairbought = 2
+      record.stairowned = 3
+      record.equity = 2.5
+      record.jointpur = 2
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors["equity"]).to include(I18n.t("validations.sales.financial.equity.equity_over_stairowned_minus_stairbought.not_joint_purchase", equity: 2.5, staircase_difference: 1.0))
+      expect(record.errors["stairowned"]).to include(I18n.t("validations.sales.financial.stairowned.equity_over_stairowned_minus_stairbought.not_joint_purchase", equity: 2.5, staircase_difference: 1.0))
+      expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.financial.stairbought.equity_over_stairowned_minus_stairbought.not_joint_purchase", equity: 2.5, staircase_difference: 1.0))
+    end
 
-      it "does not add errors if equity is less than stairowned - stairbought and stairnum is nil" do
-        record.stairbought = 2
-        record.stairowned = 10
-        record.equity = 2
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors if equity is less than stairowned - stairbought and stairnum is nil" do
+      record.stairbought = 2
+      record.stairowned = 10
+      record.equity = 2
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "does not add errors if equity is equal stairowned - stairbought and stairnum is nil" do
-        record.stairbought = 2
-        record.stairowned = 10
-        record.equity = 8
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors if equity is equal stairowned - stairbought and stairnum is nil" do
+      record.stairbought = 2
+      record.stairowned = 10
+      record.equity = 8
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "does not add errors if stairbought is not given" do
-        record.stairbought = nil
-        record.stairowned = 10
-        record.equity = 2
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors if stairbought is not given" do
+      record.stairbought = nil
+      record.stairowned = 10
+      record.equity = 2
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "does not add errors if stairowned is not given" do
-        record.stairbought = 2
-        record.stairowned = nil
-        record.equity = 2
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors if stairowned is not given" do
+      record.stairbought = 2
+      record.stairowned = nil
+      record.equity = 2
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "does not add errors if equity is not given" do
-        record.stairbought = 2
-        record.stairowned = 10
-        record.equity = 0
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors if equity is not given" do
+      record.stairbought = 2
+      record.stairowned = 10
+      record.equity = 0
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "adds errors if stairnum is present and stairowned is not enough more than stairbought + equity" do
-        record.stairowned = 20
-        record.stairbought = 10
-        record.equity = 9
-        record.numstair = 3
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors["equity"]).to include(I18n.t("validations.sales.financial.equity.more_than_stairowned_minus_stairbought_minus_prev_staircasing", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
-        expect(record.errors["stairowned"]).to include(I18n.t("validations.sales.financial.stairowned.less_than_stairbought_plus_equity_plus_prev_staircasing", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
-        expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.financial.stairbought.more_than_stairowned_minus_equity_minus_prev_staircasing", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
-        expect(record.errors["numstair"]).to include(I18n.t("validations.sales.financial.numstair.too_high_for_stairowned_minus_stairbought_minus_equity", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
-        expect(record.errors["firststair"]).to include(I18n.t("validations.sales.financial.firststair.invalid_for_stairowned_minus_stairbought_minus_equity", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
-      end
+    it "adds errors if stairnum is present and stairowned is not enough more than stairbought + equity" do
+      record.stairowned = 20
+      record.stairbought = 10
+      record.equity = 9
+      record.numstair = 3
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors["equity"]).to include(I18n.t("validations.sales.financial.equity.more_than_stairowned_minus_stairbought_minus_prev_staircasing", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
+      expect(record.errors["stairowned"]).to include(I18n.t("validations.sales.financial.stairowned.less_than_stairbought_plus_equity_plus_prev_staircasing", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
+      expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.financial.stairbought.more_than_stairowned_minus_equity_minus_prev_staircasing", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
+      expect(record.errors["numstair"]).to include(I18n.t("validations.sales.financial.numstair.too_high_for_stairowned_minus_stairbought_minus_equity", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
+      expect(record.errors["firststair"]).to include(I18n.t("validations.sales.financial.firststair.invalid_for_stairowned_minus_stairbought_minus_equity", equity: 9, bought: 10, numprevstair: 2, equity_sum: 21, stair_total: 20))
+    end
 
-      it "does not add errors if stairnum is present and stairowned is enough more than stairbought + equity" do
-        record.stairowned = 25
-        record.stairbought = 10
-        record.equity = 9
-        record.numstair = 3
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors if stairnum is present and stairowned is enough more than stairbought + equity" do
+      record.stairowned = 25
+      record.stairbought = 10
+      record.equity = 9
+      record.numstair = 3
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors).to be_empty
+    end
 
-      it "does not add errors if stairnum is present and stairowned exactly equals minimum" do
-        record.stairowned = 20
-        record.stairbought = 10
-        record.equity = 9
-        record.numstair = 2
-        financial_validator.validate_staircase_difference(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors if stairnum is present and stairowned exactly equals minimum" do
+      record.stairowned = 20
+      record.stairbought = 10
+      record.equity = 9
+      record.numstair = 2
+      financial_validator.validate_staircase_difference(record)
+      expect(record.errors).to be_empty
     end
   end
 end
diff --git a/spec/models/validations/sales/household_validations_spec.rb b/spec/models/validations/sales/household_validations_spec.rb
index cffb42ab1..ec7a3c88b 100644
--- a/spec/models/validations/sales/household_validations_spec.rb
+++ b/spec/models/validations/sales/household_validations_spec.rb
@@ -1,6 +1,8 @@
 require "rails_helper"
 
 RSpec.describe Validations::Sales::HouseholdValidations do
+  include CollectionTimeHelper
+
   subject(:household_validator) { validator_class.new }
 
   let(:validator_class) { Class.new { include Validations::Sales::HouseholdValidations } }
@@ -8,272 +10,112 @@ RSpec.describe Validations::Sales::HouseholdValidations do
   let(:saledate) { Time.zone.now }
 
   describe "#validate_partner_count" do
-    let(:saledate) { Time.zone.local(2023, 4, 1) }
+    let(:saledate) { current_collection_start_date }
 
-    it "validates that only 1 partner exists" do
+    it "does not validate" do
       record.relat2 = "P"
       record.relat3 = "P"
       household_validator.validate_partner_count(record)
-      expect(record.errors["relat2"])
-        .to include(match I18n.t("validations.sales.household.relat.one_partner"))
-      expect(record.errors["relat3"])
-        .to include(match I18n.t("validations.sales.household.relat.one_partner"))
-      expect(record.errors["relat4"])
-        .not_to include(match I18n.t("validations.sales.household.relat.one_partner"))
-    end
-
-    it "expects that a tenant can have a partner" do
-      record.relat3 = "P"
-      household_validator.validate_partner_count(record)
-      expect(record.errors["base"]).to be_empty
+      expect(record.errors["relat2"]).to be_empty
+      expect(record.errors["relat3"]).to be_empty
+      expect(record.errors["relat4"]).to be_empty
     end
   end
 
   describe "#validate_person_age_matches_relationship" do
-    context "with 2023 logs" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
-
-      context "when the household contains a person under 16" do
-        it "expects that person is a child of the tenant" do
-          record.age2 = 14
-          record.relat2 = "C"
-          household_validator.validate_person_age_matches_relationship(record)
-          expect(record.errors["relat2"]).to be_empty
-          expect(record.errors["age2"]).to be_empty
-        end
+    let(:saledate) { current_collection_start_date }
 
-        it "validates that a person under 16 must not be a partner of the buyer" do
-          record.age2 = 14
-          record.relat2 = "P"
-          household_validator.validate_person_age_matches_relationship(record)
-          expect(record.errors["relat2"])
-            .to include(match I18n.t("validations.sales.household.relat.child_under_16", person_num: 2))
-          expect(record.errors["age2"])
-            .to include(match I18n.t("validations.sales.household.age.child_under_16", person_num: 2))
-        end
-      end
-
-      it "validates that a person over 20 must not be a child of the buyer" do
-        record.age2 = 21
-        record.relat2 = "C"
-        household_validator.validate_person_age_matches_relationship(record)
-        expect(record.errors["relat2"])
-          .to include(match I18n.t("validations.sales.household.relat.child_over_20"))
-        expect(record.errors["age2"])
-          .to include(match I18n.t("validations.sales.household.age.child_over_20"))
-      end
+    it "does not add error if person under 16 is a partner" do
+      record.age2 = 14
+      record.relat2 = "P"
+      household_validator.validate_person_age_matches_relationship(record)
+      expect(record.errors["relat2"]).to be_empty
+      expect(record.errors["age2"]).to be_empty
     end
 
-    context "with 2024 logs" do
-      let(:saledate) { Time.zone.local(2024, 4, 1) }
-
-      it "does not add error if person under 16 is a partner" do
-        record.age2 = 14
-        record.relat2 = "P"
-        household_validator.validate_person_age_matches_relationship(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "does not add error if person over 19 is a child" do
-        record.age2 = 20
-        record.relat2 = "C"
-        household_validator.validate_person_age_matches_relationship(record)
-        expect(record.errors["age2"]).to be_empty
-        expect(record.errors["relat2"]).to be_empty
-      end
+    it "does not add error if person over 19 is a child" do
+      record.age2 = 20
+      record.relat2 = "C"
+      household_validator.validate_person_age_matches_relationship(record)
+      expect(record.errors["age2"]).to be_empty
+      expect(record.errors["relat2"]).to be_empty
     end
   end
 
   describe "#validate_person_age_matches_economic_status" do
-    context "with 2023 logs" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
+    let(:saledate) { current_collection_start_date }
 
-      it "validates that person's economic status must be Child" do
-        record.age2 = 14
-        record.ecstat2 = 1
-        household_validator.validate_person_age_matches_economic_status(record)
-        expect(record.errors["ecstat2"])
-          .to include(match I18n.t("validations.sales.household.ecstat.child_under_16", person_num: 2))
-        expect(record.errors["age2"])
-          .to include(match I18n.t("validations.sales.household.age.child_under_16_ecstat", person_num: 2))
-      end
-
-      it "expects that person's economic status is Child" do
-        record.age2 = 14
-        record.ecstat2 = 9
-        household_validator.validate_person_age_matches_economic_status(record)
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "validates that a person with economic status 'child' must be under 16" do
-        record.age2 = 21
-        record.ecstat2 = 9
-        household_validator.validate_person_age_matches_economic_status(record)
-        expect(record.errors["ecstat2"])
-          .to include(match I18n.t("validations.sales.household.ecstat.child_over_16", person_num: 2))
-        expect(record.errors["age2"])
-          .to include(match I18n.t("validations.sales.household.age.child_over_16", person_num: 2))
-      end
-    end
-
-    context "with 2024 logs" do
-      let(:saledate) { Time.zone.local(2024, 4, 1) }
-
-      it "does not run the validation" do
-        record.age2 = 14
-        record.ecstat2 = 1
-        household_validator.validate_person_age_matches_economic_status(record)
-        expect(record.errors["ecstat2"])
-          .not_to include(match I18n.t("validations.sales.household.ecstat.child_under_16", person_num: 2))
-        expect(record.errors["age2"])
-          .not_to include(match I18n.t("validations.sales.household.age.child_under_16_ecstat", person_num: 2))
-      end
+    it "validates that a person with economic status 'child' must be under 16" do
+      record.age2 = 21
+      record.ecstat2 = 9
+      household_validator.validate_person_age_matches_economic_status(record)
+      expect(record.errors["ecstat2"])
+        .to include(match I18n.t("validations.sales.household.ecstat.child_over_16", person_num: 2))
+      expect(record.errors["age2"])
+        .to include(match I18n.t("validations.sales.household.age.child_over_16", person_num: 2))
     end
   end
 
   describe "#validate_child_12_years_younger" do
-    context "with 2023 logs" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
-
-      it "validates the child is at least 12 years younger than buyer 1" do
-        record.age1 = 30
-        record.age2 = record.age1 - 11
-        record.relat2 = "C"
-        household_validator.validate_child_12_years_younger(record)
-        expect(record.errors["age1"])
-          .to include(match I18n.t("validations.sales.household.age.child_12_years_younger", person_num: 2))
-        expect(record.errors["age2"])
-          .to include(match I18n.t("validations.sales.household.age.child_12_years_younger", person_num: 2))
-        expect(record.errors["relat2"])
-          .to include(match I18n.t("validations.sales.household.age.child_12_years_younger", person_num: 2))
-      end
-
-      it "expects the child is at least 12 years younger than buyer 1" do
-        record.age1 = 30
-        record.age2 = record.age1 - 12
-        record.relat2 = "C"
-        household_validator.validate_child_12_years_younger(record)
-        expect(record.errors["age1"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-        expect(record.errors["relate2"]).to be_empty
-      end
-    end
-
-    context "with 2024 logs" do
-      let(:saledate) { Time.zone.local(2024, 4, 1) }
+    let(:saledate) { current_collection_start_date }
 
-      it "does not validate that child is at least 12 year younger than buyer" do
-        record.age1 = 20
-        record.age2 = 17
-        record.relat2 = "C"
-        household_validator.validate_child_12_years_younger(record)
-        expect(record.errors["age1"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-        expect(record.errors["relat2"]).to be_empty
-      end
+    it "does not validate that child is at least 12 year younger than buyer" do
+      record.age1 = 20
+      record.age2 = 17
+      record.relat2 = "C"
+      household_validator.validate_child_12_years_younger(record)
+      expect(record.errors["age1"]).to be_empty
+      expect(record.errors["age2"]).to be_empty
+      expect(record.errors["relat2"]).to be_empty
     end
   end
 
   describe "#validate_person_age_and_relationship_matches_economic_status" do
-    context "with 2023 logs" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
+    let(:saledate) { current_collection_start_date }
 
-      it "does not add an error for a person aged 16-19 who is a student but not a child of the buyer" do
-        record.age2 = 18
-        record.ecstat2 = "7"
-        record.relat2 = "P"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "does not add an error for a person not aged 16-19 who is a student but not a child of the buyer" do
-        record.age2 = 20
-        record.ecstat2 = "7"
-        record.relat2 = "P"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "adds errors for a person aged 16-19 who is a child of the buyer but not a student" do
+    context "when the household contains a tenant’s child between the ages of 16 and 19" do
+      it "does not add an error" do
         record.age2 = 17
-        record.ecstat2 = "1"
         record.relat2 = "C"
+        record.ecstat2 = 1
         household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"])
-          .to include(match I18n.t("validations.sales.household.relat.student_16_19.cannot_be_child.16_19_not_student"))
-        expect(record.errors["age2"])
-          .to include(match I18n.t("validations.sales.household.age.student_16_19.cannot_be_16_19.child_not_student"))
         expect(record.errors["ecstat2"])
-          .to include(match I18n.t("validations.sales.household.ecstat.student_16_19.must_be_student"))
-      end
-
-      it "adds errors for a person who is a child of the buyer and a student but not aged 16-19" do
-        record.age2 = 14
-        record.ecstat2 = "7"
-        record.relat2 = "C"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"])
-          .to include(match I18n.t("validations.sales.household.relat.student_16_19.cannot_be_child.student_not_16_19"))
+          .to be_empty
         expect(record.errors["age2"])
-          .to include(match I18n.t("validations.sales.household.age.student_16_19.must_be_16_19"))
-        expect(record.errors["ecstat2"])
-          .to include(match I18n.t("validations.sales.household.ecstat.student_16_19.cannot_be_student.child_not_16_19"))
+          .to be_empty
+        expect(record.errors["relat2"])
+          .to be_empty
       end
     end
 
-    context "with 2024 logs" do
-      let(:saledate) { Time.zone.local(2024, 4, 1) }
-
-      context "when the household contains a tenant’s child between the ages of 16 and 19" do
-        it "does not add an error" do
-          record.age2 = 17
-          record.relat2 = "C"
-          record.ecstat2 = 1
-          household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-          expect(record.errors["ecstat2"])
-            .to be_empty
-          expect(record.errors["age2"])
-            .to be_empty
-          expect(record.errors["relat2"])
-            .to be_empty
-        end
-      end
-
-      it "does not add an error for a person not aged 16-19 who is a student but not a child of the buyer" do
-        record.age2 = 20
-        record.ecstat2 = "7"
-        record.relat2 = "P"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "does not add errors" do
-        record.age2 = 14
-        record.ecstat2 = "7"
-        record.relat2 = "C"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
-
-      it "does not add errors for a person who is a student and aged 16-19 but not child" do
-        record.age2 = 17
-        record.ecstat2 = "7"
-        record.relat2 = "X"
-        household_validator.validate_person_age_and_relationship_matches_economic_status(record)
-        expect(record.errors["relat2"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-        expect(record.errors["age2"]).to be_empty
-      end
+    it "does not add an error for a person not aged 16-19 who is a student but not a child of the buyer" do
+      record.age2 = 20
+      record.ecstat2 = "7"
+      record.relat2 = "P"
+      household_validator.validate_person_age_and_relationship_matches_economic_status(record)
+      expect(record.errors["relat2"]).to be_empty
+      expect(record.errors["ecstat2"]).to be_empty
+      expect(record.errors["age2"]).to be_empty
+    end
+
+    it "does not add errors" do
+      record.age2 = 14
+      record.ecstat2 = "7"
+      record.relat2 = "C"
+      household_validator.validate_person_age_and_relationship_matches_economic_status(record)
+      expect(record.errors["relat2"]).to be_empty
+      expect(record.errors["ecstat2"]).to be_empty
+      expect(record.errors["age2"]).to be_empty
+    end
+
+    it "does not add errors for a person who is a student and aged 16-19 but not child" do
+      record.age2 = 17
+      record.ecstat2 = "7"
+      record.relat2 = "X"
+      household_validator.validate_person_age_and_relationship_matches_economic_status(record)
+      expect(record.errors["relat2"]).to be_empty
+      expect(record.errors["ecstat2"]).to be_empty
+      expect(record.errors["age2"]).to be_empty
     end
   end
 
@@ -310,16 +152,12 @@ RSpec.describe Validations::Sales::HouseholdValidations do
           expect(sales_log.errors).to be_empty
         end
 
-        context "with 2023 logs" do
-          let(:saledate) { Time.zone.local(2023, 4, 1) }
-
-          it "triggers a validation if buyer two will also not live in the property" do
-            sales_log.buy2livein = 2
-            household_validator.validate_buyers_living_in_property(sales_log)
-            expect(sales_log.errors[:buylivein]).to include I18n.t("validations.sales.household.buylivein.buyers_will_live_in_property_values_inconsistent")
-            expect(sales_log.errors[:buy2livein]).to include I18n.t("validations.sales.household.buy2livein.buyers_will_live_in_property_values_inconsistent")
-            expect(sales_log.errors[:buy1livein]).to include I18n.t("validations.sales.household.buy1livein.buyers_will_live_in_property_values_inconsistent")
-          end
+        it "triggers a validation if buyer two will also not live in the property" do
+          sales_log.buy2livein = 2
+          household_validator.validate_buyers_living_in_property(sales_log)
+          expect(sales_log.errors[:buylivein]).to include I18n.t("validations.sales.household.buylivein.buyers_will_live_in_property_values_inconsistent")
+          expect(sales_log.errors[:buy2livein]).to include I18n.t("validations.sales.household.buy2livein.buyers_will_live_in_property_values_inconsistent")
+          expect(sales_log.errors[:buy1livein]).to include I18n.t("validations.sales.household.buy1livein.buyers_will_live_in_property_values_inconsistent")
         end
       end
 
@@ -383,60 +221,31 @@ RSpec.describe Validations::Sales::HouseholdValidations do
         expect(record.errors).to be_empty
       end
     end
-
-    context "with 23/24 logs" do
-      let(:saledate) { Time.zone.local(2023, 4, 4) }
-
-      it "does not add an error for outright sale" do
-        record.ownershipsch = 2
-
-        [1, 2, 3, 4, 5, 6, 7, 9, 0].each do |prevten|
-          record.prevten = prevten
-          household_validator.validate_buyer1_previous_tenure(record)
-          expect(record.errors).to be_empty
-        end
-      end
-    end
   end
 
   describe "#validate_buyer_not_child" do
-    context "with 2023 logs" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
-
-      it "does not add an error if either buyer is a child" do
-        record.jointpur = 1
-        record.ecstat1 = 9
-        record.ecstat2 = 9
-        household_validator.validate_buyer_not_child(record)
-        expect(record.errors["ecstat1"]).to be_empty
-        expect(record.errors["ecstat2"]).to be_empty
-      end
-    end
-
-    context "with 2024 logs" do
-      let(:saledate) { Time.zone.local(2024, 4, 1) }
+    let(:saledate) { current_collection_start_date }
 
-      it "validates buyer 1 isn't a child" do
-        record.ecstat1 = 9
-        household_validator.validate_buyer_not_child(record)
-        expect(record.errors["ecstat1"])
-          .to include("Buyer 1 cannot have a working situation of child under 16.")
-      end
+    it "validates buyer 1 isn't a child" do
+      record.ecstat1 = 9
+      household_validator.validate_buyer_not_child(record)
+      expect(record.errors["ecstat1"])
+        .to include("Buyer 1 cannot have a working situation of child under 16.")
+    end
 
-      it "validates buyer 2 isn't a child" do
-        record.jointpur = 1
-        record.ecstat2 = 9
-        household_validator.validate_buyer_not_child(record)
-        expect(record.errors["ecstat2"])
-          .to include("Buyer 2 cannot have a working situation of child under 16.")
-      end
+    it "validates buyer 2 isn't a child" do
+      record.jointpur = 1
+      record.ecstat2 = 9
+      household_validator.validate_buyer_not_child(record)
+      expect(record.errors["ecstat2"])
+        .to include("Buyer 2 cannot have a working situation of child under 16.")
+    end
 
-      it "allows person 2 to be a child" do
-        record.jointpur = 2
-        record.ecstat2 = 9
-        household_validator.validate_buyer_not_child(record)
-        expect(record.errors["ecstat2"]).to be_empty
-      end
+    it "allows person 2 to be a child" do
+      record.jointpur = 2
+      record.ecstat2 = 9
+      household_validator.validate_buyer_not_child(record)
+      expect(record.errors["ecstat2"]).to be_empty
     end
   end
 end
diff --git a/spec/models/validations/sales/property_validations_spec.rb b/spec/models/validations/sales/property_validations_spec.rb
index 62b65ee36..5458da5a9 100644
--- a/spec/models/validations/sales/property_validations_spec.rb
+++ b/spec/models/validations/sales/property_validations_spec.rb
@@ -1,80 +1,21 @@
 require "rails_helper"
 
 RSpec.describe Validations::Sales::PropertyValidations do
+  include CollectionTimeHelper
+
   subject(:property_validator) { property_validator_class.new }
 
   let(:property_validator_class) { Class.new { include Validations::Sales::PropertyValidations } }
 
   describe "#validate_postcodes_match_if_discounted_ownership" do
-    context "when ownership scheme is not discounted ownership" do
-      let(:record) { build(:sales_log, ownershipsch: 1) }
-
-      it "when postcodes match no error is added" do
-        record.postcode_full = "SW1A 1AA"
-        record.ppostcode_full = "SW1A 1AA"
-
-        property_validator.validate_postcodes_match_if_discounted_ownership(record)
-        expect(record.errors["postcode_full"]).to be_empty
-      end
-    end
-
-    context "when ownership scheme is discounted ownership" do
-      let(:record) { build(:sales_log, ownershipsch: 2, saledate: Time.zone.local(2023, 4, 5)) }
-
-      it "when ppostcode_full is not present no error is added" do
-        record.postcode_full = "SW1A 1AA"
-        property_validator.validate_postcodes_match_if_discounted_ownership(record)
-        expect(record.errors["postcode_full"]).to be_empty
-        expect(record.errors["ppostcode_full"]).to be_empty
-        expect(record.errors["ownershipsch"]).to be_empty
-      end
+    let(:record) { build(:sales_log, ownershipsch: 1, saledate: current_collection_start_date) }
 
-      it "when postcode_full is not present no error is added" do
-        record.ppostcode_full = "SW1A 1AA"
-        property_validator.validate_postcodes_match_if_discounted_ownership(record)
-        expect(record.errors["postcode_full"]).to be_empty
-        expect(record.errors["ppostcode_full"]).to be_empty
-        expect(record.errors["ownershipsch"]).to be_empty
-      end
-
-      it "when postcodes match no error is added" do
-        record.postcode_full = "SW1A 1AA"
-        record.ppostcode_full = "SW1A 1AA"
-        property_validator.validate_postcodes_match_if_discounted_ownership(record)
-        expect(record.errors["postcode_full"]).to be_empty
-        expect(record.errors["ppostcode_full"]).to be_empty
-        expect(record.errors["ownershipsch"]).to be_empty
-      end
-
-      it "when postcodes do not match an error is added for joint purchase" do
-        record.postcode_full = "SW1A 1AA"
-        record.ppostcode_full = "SW1A 0AA"
-        record.jointpur = 1
-        property_validator.validate_postcodes_match_if_discounted_ownership(record)
-        expect(record.errors["postcode_full"]).to include("Buyers’ last accommodation and discounted ownership postcodes must match.")
-        expect(record.errors["ppostcode_full"]).to include("Buyers’ last accommodation and discounted ownership postcodes must match.")
-        expect(record.errors["ownershipsch"]).to include("Buyers’ last accommodation and discounted ownership postcodes must match.")
-      end
-
-      it "when postcodes do not match an error is added for non joint purchase" do
-        record.postcode_full = "SW1A 1AA"
-        record.ppostcode_full = "SW1A 0AA"
-        record.jointpur = 2
-        property_validator.validate_postcodes_match_if_discounted_ownership(record)
-        expect(record.errors["postcode_full"]).to include("Buyer’s last accommodation and discounted ownership postcodes must match.")
-        expect(record.errors["ppostcode_full"]).to include("Buyer’s last accommodation and discounted ownership postcodes must match.")
-        expect(record.errors["ownershipsch"]).to include("Buyer’s last accommodation and discounted ownership postcodes must match.")
-      end
+    it "is not validated" do
+      record.postcode_full = "SW1A 1AA"
+      record.ppostcode_full = "SW1A 0AA"
 
-      it "does not add error for 2024 log" do
-        record.postcode_full = "SW1A 1AA"
-        record.ppostcode_full = "SW1A 0AA"
-        record.saledate = Time.zone.local(2024, 4, 5)
-        property_validator.validate_postcodes_match_if_discounted_ownership(record)
-        expect(record.errors["postcode_full"]).to be_empty
-        expect(record.errors["ppostcode_full"]).to be_empty
-        expect(record.errors["ownershipsch"]).to be_empty
-      end
+      property_validator.validate_postcodes_match_if_discounted_ownership(record)
+      expect(record.errors["postcode_full"]).to be_empty
     end
   end
 
diff --git a/spec/models/validations/sales/sale_information_validations_spec.rb b/spec/models/validations/sales/sale_information_validations_spec.rb
index a43e0e639..56007b629 100644
--- a/spec/models/validations/sales/sale_information_validations_spec.rb
+++ b/spec/models/validations/sales/sale_information_validations_spec.rb
@@ -1,6 +1,8 @@
 require "rails_helper"
 
 RSpec.describe Validations::Sales::SaleInformationValidations do
+  include CollectionTimeHelper
+
   subject(:sale_information_validator) { validator_class.new }
 
   let(:validator_class) { Class.new { include Validations::Sales::SaleInformationValidations } }
@@ -47,7 +49,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when hodate less than 3 years before saledate" do
-      let(:record) { build(:sales_log, hodate: Date.new(2021, 12, 2), saledate: Date.new(2024, 12, 1)) }
+      let(:record) { build(:sales_log, hodate: current_collection_start_date - 3.years + 1.day, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_practical_completion_date(record)
@@ -57,8 +59,8 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when hodate 3 or more years before saledate" do
-      context "and form year is 2023 or earlier" do
-        let(:record) { build(:sales_log, hodate: Date.new(2020, 12, 1), saledate: Date.new(2023, 12, 1)) }
+      context "and form year is 2024 or earlier" do
+        let(:record) { build(:sales_log, hodate: previous_collection_start_date - 3.years, saledate: previous_collection_start_date) }
 
         it "does add an error" do
           sale_information_validator.validate_practical_completion_date(record)
@@ -68,17 +70,29 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
         end
       end
 
-      context "and form year is 2024 or later" do
-        let(:record) { build(:sales_log, hodate: Date.new(2021, 12, 1), saledate: Date.new(2024, 12, 1)) }
+      context "and form year is 2025 or later" do
+        let(:record) { build(:sales_log, hodate: current_collection_start_date - 3.years, saledate: current_collection_start_date) }
 
-        it "adds an error" do
+        it "does not add an error" do
           sale_information_validator.validate_practical_completion_date(record)
 
-          expect(record.errors[:hodate]).to be_present
+          expect(record.errors[:hodate]).to be_empty
+          expect(record.errors[:saledate]).to be_empty
         end
       end
     end
 
+    context "when hodate 5 or more years before saledate" do
+      let(:record) { build(:sales_log, hodate: current_collection_start_date - 5.years, saledate: current_collection_start_date) }
+
+      it "does add an error" do
+        sale_information_validator.validate_practical_completion_date(record)
+
+        expect(record.errors[:hodate]).to be_present
+        expect(record.errors[:saledate]).to be_present
+      end
+    end
+
     context "when hodate after saledate" do
       let(:record) { build(:sales_log, hodate: 1.month.ago, saledate: 2.months.ago) }
 
@@ -90,7 +104,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when hodate == saledate" do
-      let(:record) { build(:sales_log, hodate: Time.zone.parse("2023-07-01"), saledate: Time.zone.parse("2023-07-01")) }
+      let(:record) { build(:sales_log, hodate: current_collection_start_date, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_practical_completion_date(record)
@@ -172,7 +186,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when exdate == saledate" do
-      let(:record) { build(:sales_log, exdate: Time.zone.parse("2023-07-01"), saledate: Time.zone.parse("2023-07-01")) }
+      let(:record) { build(:sales_log, exdate: current_collection_start_date, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_exchange_date(record)
@@ -235,7 +249,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when initial purchase date == saledate" do
-      let(:record) { build(:sales_log, initialpurchase: Time.zone.parse("2023-07-01"), saledate: Time.zone.parse("2023-07-01")) }
+      let(:record) { build(:sales_log, initialpurchase: current_collection_start_date, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_staircasing_initial_purchase_date(record)
@@ -298,7 +312,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when last transaction date == saledate" do
-      let(:record) { build(:sales_log, lasttransaction: Time.zone.parse("2023-07-01"), saledate: Time.zone.parse("2023-07-01")) }
+      let(:record) { build(:sales_log, lasttransaction: current_collection_start_date, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_staircasing_last_transaction_date(record)
@@ -329,7 +343,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when last transaction date == initial purchase date" do
-      let(:record) { build(:sales_log, lasttransaction: Time.zone.parse("2023-07-01"), initialpurchase: Time.zone.parse("2023-07-01")) }
+      let(:record) { build(:sales_log, lasttransaction: current_collection_start_date, initialpurchase: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_staircasing_last_transaction_date(record)
@@ -649,109 +663,79 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
         expect(record.errors["grant"]).to be_empty
       end
     end
-
-    context "when it is a 2023 log" do
-      let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, deposit: 5_000, grant: 3_000, value: 20_000, discount: 10, ownershipsch: 2, saledate: Time.zone.local(2023, 4, 1)) }
-
-      it "returns false" do
-        record.mortgage = 10
-        sale_information_validator.validate_discounted_ownership_value(record)
-        expect(record.errors["mortgageused"]).to be_empty
-        expect(record.errors["mortgage"]).to be_empty
-        expect(record.errors["value"]).to be_empty
-        expect(record.errors["deposit"]).to be_empty
-        expect(record.errors["ownershipsch"]).to be_empty
-        expect(record.errors["discount"]).to be_empty
-        expect(record.errors["grant"]).to be_empty
-      end
-    end
   end
 
   describe "#validate_outright_sale_value_matches_mortgage_plus_deposit" do
-    context "with a 2024 outright sale log" do
-      let(:record) { FactoryBot.build(:sales_log, value: 300_000, ownershipsch: 3, saledate: Time.zone.local(2024, 5, 1)) }
+    let(:record) { FactoryBot.build(:sales_log, value: 300_000, ownershipsch: 3, saledate: current_collection_start_date) }
+
+    context "when a mortgage is used" do
+      before do
+        record.mortgageused = 1
+      end
 
-      context "when a mortgage is used" do
+      context "and the mortgage plus deposit match the value" do
         before do
-          record.mortgageused = 1
+          record.mortgage = 200_000
+          record.deposit = 100_000
         end
 
-        context "and the mortgage plus deposit match the value" do
-          before do
-            record.mortgage = 200_000
-            record.deposit = 100_000
-          end
-
-          it "does not add errors" do
-            sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
-            expect(record.errors).to be_empty
-          end
+        it "does not add errors" do
+          sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
+          expect(record.errors).to be_empty
         end
+      end
 
-        context "and the mortgage plus deposit don't match the value" do
-          before do
-            record.mortgage = 100_000
-            record.deposit = 100_000
-          end
-
-          it "adds errors" do
-            sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
-            expect(record.errors["mortgageused"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["mortgage"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["deposit"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["value"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["ownershipsch"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
-          end
+      context "and the mortgage plus deposit don't match the value" do
+        before do
+          record.mortgage = 100_000
+          record.deposit = 100_000
         end
 
-        context "and deposit is not provided" do
-          before do
-            record.mortgage = 100_000
-            record.deposit = nil
-          end
-
-          it "does not add errors" do
-            sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
-            expect(record.errors).to be_empty
-          end
+        it "adds errors" do
+          sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
+          expect(record.errors["mortgageused"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["mortgage"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["deposit"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["value"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["ownershipsch"]).to include("The mortgage (£100,000.00) and cash deposit (£100,000.00) when added together is £200,000.00.</br></br>The full purchase price is £300,000.00.</br></br>These two amounts should be the same.")
         end
+      end
 
-        context "and mortgage is not provided" do
-          before do
-            record.mortgage = nil
-            record.deposit = 100_000
-          end
+      context "and deposit is not provided" do
+        before do
+          record.mortgage = 100_000
+          record.deposit = nil
+        end
 
-          it "does not add errors" do
-            sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
-            expect(record.errors).to be_empty
-          end
+        it "does not add errors" do
+          sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
+          expect(record.errors).to be_empty
         end
       end
-    end
 
-    context "with a 2024 log that is not an outright sale" do
-      let(:record) { FactoryBot.build(:sales_log, value: 300_000, ownershipsch: 2, saledate: Time.zone.local(2024, 5, 1)) }
+      context "and mortgage is not provided" do
+        before do
+          record.mortgage = nil
+          record.deposit = 100_000
+        end
 
-      it "does not add errors" do
-        record.mortgageused = 1
-        record.mortgage = 100_000
-        record.deposit = 100_000
-        sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
-        expect(record.errors).to be_empty
+        it "does not add errors" do
+          sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
+          expect(record.errors).to be_empty
+        end
       end
     end
+  end
 
-    context "with a 2023 outright sale log" do
-      let(:record) { FactoryBot.build(:sales_log, value: 300_000, ownershipsch: 3, saledate: Time.zone.local(2023, 5, 1)) }
+  context "with a 2024 log that is not an outright sale" do
+    let(:record) { FactoryBot.build(:sales_log, value: 300_000, ownershipsch: 2, saledate: Time.zone.local(2024, 5, 1)) }
 
-      it "does not add errors" do
-        record.mortgageused = 1
-        record.mortgage = 100_000
-        record.deposit = 100_000
-        sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
-        expect(record.errors).to be_empty
-      end
+    it "does not add errors" do
+      record.mortgageused = 1
+      record.mortgage = 100_000
+      record.deposit = 100_000
+      sale_information_validator.validate_outright_sale_value_matches_mortgage_plus_deposit(record)
+      expect(record.errors).to be_empty
     end
   end
 
@@ -814,7 +798,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
 
   describe "#validate_grant_amount" do
     context "when within permitted bounds" do
-      let(:record) { build(:sales_log, grant: 10_000, saledate: Time.zone.local(2024, 4, 5)) }
+      let(:record) { build(:sales_log, grant: 10_000, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_grant_amount(record)
@@ -824,7 +808,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when over the max" do
-      let(:record) { build(:sales_log, type: 8, grant: 17_000, saledate: Time.zone.local(2024, 4, 5)) }
+      let(:record) { build(:sales_log, type: 8, grant: 17_000, saledate: current_collection_start_date) }
 
       it "adds an error" do
         sale_information_validator.validate_grant_amount(record)
@@ -834,7 +818,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when under the min" do
-      let(:record) { build(:sales_log, type: 21, grant: 3, saledate: Time.zone.local(2024, 4, 5)) }
+      let(:record) { build(:sales_log, type: 21, grant: 3, saledate: current_collection_start_date) }
 
       it "adds an error" do
         sale_information_validator.validate_grant_amount(record)
@@ -844,7 +828,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when grant is blank" do
-      let(:record) { build(:sales_log, type: 21, grant: nil, saledate: Time.zone.local(2024, 4, 5)) }
+      let(:record) { build(:sales_log, type: 21, grant: nil, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_grant_amount(record)
@@ -854,7 +838,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when over the max and type is not RTA of social homebuy" do
-      let(:record) { build(:sales_log, type: 9, grant: 17_000, saledate: Time.zone.local(2024, 4, 5)) }
+      let(:record) { build(:sales_log, type: 9, grant: 17_000, saledate: current_collection_start_date) }
 
       it "does not add an error" do
         sale_information_validator.validate_grant_amount(record)
@@ -864,7 +848,7 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when under the min and type is not RTA of social homebuy" do
-      let(:record) { build(:sales_log, type: 9, grant: 17_000, saledate: Time.zone.local(2024, 4, 5)) }
+      let(:record) { build(:sales_log, type: 9, grant: 17_000, saledate: current_collection_start_date) }
 
       it "does not add error" do
         sale_information_validator.validate_grant_amount(record)
@@ -872,20 +856,10 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
         expect(record.errors).not_to be_present
       end
     end
-
-    context "with log before 2024/25 collection" do
-      let(:record) { build(:sales_log, type: 8, grant: 3, saledate: Time.zone.local(2023, 4, 5)) }
-
-      it "does not add an error" do
-        sale_information_validator.validate_grant_amount(record)
-
-        expect(record.errors).not_to be_present
-      end
-    end
   end
 
   describe "#validate_stairbought" do
-    let(:saledate) { Time.zone.local(2024, 4, 4) }
+    let(:saledate) { current_collection_start_date }
 
     [
       ["Shared Ownership (new model lease)", 30, 90],
@@ -930,88 +904,63 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
         end
       end
     end
-    context "when the collection year is before 2024" do
-      let(:record) { build(:sales_log, ownershipsch: 1, type: 24, saledate:, stairbought: 90) }
-      let(:saledate) { Time.zone.local(2023, 4, 4) }
-
-      it "does not add an error" do
-        sale_information_validator.validate_stairbought(record)
-
-        expect(record.errors).to be_empty
-      end
-    end
   end
 
   describe "#validate_discount_and_value" do
     let(:record) { FactoryBot.build(:sales_log, value: 200_000, discount: 50, ownershipsch: 2, type: 9, saledate:) }
-    let(:saledate) { Time.zone.local(2024, 4, 1) }
-
-    context "with a log in the 24/25 collection year" do
-      context "when in London" do
-        before do
-          record.la = "E09000001"
-        end
-
-        it "adds an error if value * discount is more than 137,400" do
-          record.value = 200_000
-          record.discount = 80
-          discount_value = "£160,000.00"
-          sale_information_validator.validate_discount_and_value(record)
-          expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.value_over_discounted_london_max", discount_value:))
-          expect(record.errors["discount"]).to include(I18n.t("validations.sales.sale_information.discount.value_over_discounted_london_max", discount_value:))
-          expect(record.errors["la"]).to include(I18n.t("validations.sales.sale_information.la.value_over_discounted_london_max", discount_value:))
-          expect(record.errors["postcode_full"]).to include(I18n.t("validations.sales.sale_information.postcode_full.value_over_discounted_london_max", discount_value:))
-          expect(record.errors["uprn"]).to include(I18n.t("validations.sales.sale_information.uprn.value_over_discounted_london_max", discount_value:))
-        end
+    let(:saledate) { current_collection_start_date }
 
-        it "does not add an error value * discount is less than 137,400" do
-          record.value = 200_000
-          record.discount = 50
-          # Discount value: 100,000
-          sale_information_validator.validate_discount_and_value(record)
-          expect(record.errors["value"]).to be_empty
-          expect(record.errors["discount"]).to be_empty
-          expect(record.errors["la"]).to be_empty
-          expect(record.errors["postcode_full"]).to be_empty
-          expect(record.errors["uprn"]).to be_empty
-        end
+    context "when in London" do
+      before do
+        record.la = "E09000001"
       end
 
-      context "when in outside of London" do
-        before do
-          record.la = "E06000015"
-        end
-
-        it "adds an error if value * discount is more than 103,400" do
-          record.value = 200_000
-          record.discount = 52
-          discount_value = "£104,000.00"
-          sale_information_validator.validate_discount_and_value(record)
-          expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.value_over_discounted_max", discount_value:))
-          expect(record.errors["discount"]).to include(I18n.t("validations.sales.sale_information.discount.value_over_discounted_max", discount_value:))
-          expect(record.errors["la"]).to include(I18n.t("validations.sales.sale_information.la.value_over_discounted_max", discount_value:))
-          expect(record.errors["postcode_full"]).to include(I18n.t("validations.sales.sale_information.postcode_full.value_over_discounted_max", discount_value:))
-          expect(record.errors["uprn"]).to include(I18n.t("validations.sales.sale_information.uprn.value_over_discounted_max", discount_value:))
-        end
+      it "adds an error if value * discount is more than 137,400" do
+        record.value = 200_000
+        record.discount = 80
+        discount_value = "£160,000.00"
+        sale_information_validator.validate_discount_and_value(record)
+        expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.value_over_discounted_london_max", discount_value:))
+        expect(record.errors["discount"]).to include(I18n.t("validations.sales.sale_information.discount.value_over_discounted_london_max", discount_value:))
+        expect(record.errors["la"]).to include(I18n.t("validations.sales.sale_information.la.value_over_discounted_london_max", discount_value:))
+        expect(record.errors["postcode_full"]).to include(I18n.t("validations.sales.sale_information.postcode_full.value_over_discounted_london_max", discount_value:))
+        expect(record.errors["uprn"]).to include(I18n.t("validations.sales.sale_information.uprn.value_over_discounted_london_max", discount_value:))
+      end
 
-        it "does not add an error value * discount is less than 103,400" do
-          record.value = 200_000
-          record.discount = 50
-          # Discount value: 100,000
-          sale_information_validator.validate_discount_and_value(record)
-          expect(record.errors["value"]).to be_empty
-          expect(record.errors["discount"]).to be_empty
-          expect(record.errors["la"]).to be_empty
-          expect(record.errors["postcode_full"]).to be_empty
-          expect(record.errors["uprn"]).to be_empty
-        end
+      it "does not add an error value * discount is less than 137,400" do
+        record.value = 200_000
+        record.discount = 50
+        # Discount value: 100,000
+        sale_information_validator.validate_discount_and_value(record)
+        expect(record.errors["value"]).to be_empty
+        expect(record.errors["discount"]).to be_empty
+        expect(record.errors["la"]).to be_empty
+        expect(record.errors["postcode_full"]).to be_empty
+        expect(record.errors["uprn"]).to be_empty
       end
     end
 
-    context "when it is a 2023 log" do
-      let(:record) { FactoryBot.build(:sales_log, value: 200_000, discount: 80, ownershipsch: 2, type: 9, saledate: Time.zone.local(2023, 4, 1), la: "E06000015") }
+    context "when in outside of London" do
+      before do
+        record.la = "E06000015"
+      end
 
-      it "does not add an error" do
+      it "adds an error if value * discount is more than 103,400" do
+        record.value = 200_000
+        record.discount = 52
+        discount_value = "£104,000.00"
+        sale_information_validator.validate_discount_and_value(record)
+        expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.value_over_discounted_max", discount_value:))
+        expect(record.errors["discount"]).to include(I18n.t("validations.sales.sale_information.discount.value_over_discounted_max", discount_value:))
+        expect(record.errors["la"]).to include(I18n.t("validations.sales.sale_information.la.value_over_discounted_max", discount_value:))
+        expect(record.errors["postcode_full"]).to include(I18n.t("validations.sales.sale_information.postcode_full.value_over_discounted_max", discount_value:))
+        expect(record.errors["uprn"]).to include(I18n.t("validations.sales.sale_information.uprn.value_over_discounted_max", discount_value:))
+      end
+
+      it "does not add an error value * discount is less than 103,400" do
+        record.value = 200_000
+        record.discount = 50
+        # Discount value: 100,000
         sale_information_validator.validate_discount_and_value(record)
         expect(record.errors["value"]).to be_empty
         expect(record.errors["discount"]).to be_empty
@@ -1025,62 +974,44 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
   describe "#validate_non_staircasing_mortgage" do
     let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, deposit: 5_000, value: 30_000, equity: 28, ownershipsch: 1, type: 30, saledate:) }
 
-    context "with a log in the 24/25 collection year" do
-      let(:saledate) { Time.zone.local(2024, 4, 4) }
+    let(:saledate) { current_collection_start_date }
 
-      context "when MORTGAGE + DEPOSIT does not equal VALUE * EQUITY/100 " do
-        context "and it is not a staircase transaction" do
+    context "when MORTGAGE + DEPOSIT does not equal VALUE * EQUITY/100 " do
+      context "and it is not a staircase transaction" do
+        before do
+          record.staircase = 2
+        end
+
+        it "adds an error" do
+          sale_information_validator.validate_non_staircasing_mortgage(record)
+          expect(record.errors["mortgage"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["value"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["deposit"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["equity"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["type"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+          expect(record.errors["cashdis"]).not_to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+        end
+
+        context "and it is a social homebuy" do
           before do
-            record.staircase = 2
+            record.type = 18
+            record.cashdis = "200"
           end
 
           it "adds an error" do
             sale_information_validator.validate_non_staircasing_mortgage(record)
-            expect(record.errors["mortgage"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["value"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["deposit"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["equity"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["type"]).to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-            expect(record.errors["cashdis"]).not_to include("The mortgage (£10,000.00) and cash deposit (£5,000.00) added together is £15,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-          end
-
-          context "and it is a social homebuy" do
-            before do
-              record.type = 18
-              record.cashdis = "200"
-            end
-
-            it "adds an error" do
-              sale_information_validator.validate_non_staircasing_mortgage(record)
-              expect(record.errors["mortgage"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["value"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["deposit"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["equity"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["cashdis"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["type"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-            end
-          end
-
-          context "and it is not a shared ownership transaction" do
-            before do
-              record.ownershipsch = 2
-            end
-
-            it "does not add an error" do
-              sale_information_validator.validate_non_staircasing_mortgage(record)
-              expect(record.errors["mortgage"]).to be_empty
-              expect(record.errors["value"]).to be_empty
-              expect(record.errors["deposit"]).to be_empty
-              expect(record.errors["equity"]).to be_empty
-              expect(record.errors["cashdis"]).to be_empty
-              expect(record.errors["type"]).to be_empty
-            end
+            expect(record.errors["mortgage"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["value"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["deposit"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["equity"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["cashdis"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["type"]).to include("The mortgage amount (£10,000.00), cash deposit (£5,000.00), and cash discount (£200.00) added together is £15,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage equity stake purchased (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
           end
         end
 
-        context "and it is a staircase transaction" do
+        context "and it is not a shared ownership transaction" do
           before do
-            record.staircase = 1
+            record.ownershipsch = 2
           end
 
           it "does not add an error" do
@@ -1095,8 +1026,10 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
         end
       end
 
-      context "when MORTGAGE + DEPOSIT equals VALUE * EQUITY/100" do
-        let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 2, deposit: 5_000, value: 30_000, equity: 50, ownershipsch: 1, type: 30, saledate:) }
+      context "and it is a staircase transaction" do
+        before do
+          record.staircase = 1
+        end
 
         it "does not add an error" do
           sale_information_validator.validate_non_staircasing_mortgage(record)
@@ -1108,79 +1041,77 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
           expect(record.errors["type"]).to be_empty
         end
       end
+    end
 
-      context "when MORTGAGE + DEPOSIT is within 1£ tolerance of VALUE * EQUITY/100" do
-        let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 2, deposit: 50_000, value: 120_001, equity: 50, ownershipsch: 1, type: 30, saledate:) }
+    context "when MORTGAGE + DEPOSIT equals VALUE * EQUITY/100" do
+      let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 2, deposit: 5_000, value: 30_000, equity: 50, ownershipsch: 1, type: 30, saledate:) }
 
-        it "does not add an error" do
-          sale_information_validator.validate_non_staircasing_mortgage(record)
-          expect(record.errors["mortgage"]).to be_empty
-          expect(record.errors["value"]).to be_empty
-          expect(record.errors["deposit"]).to be_empty
-          expect(record.errors["equity"]).to be_empty
-          expect(record.errors["cashdis"]).to be_empty
-          expect(record.errors["type"]).to be_empty
-        end
+      it "does not add an error" do
+        sale_information_validator.validate_non_staircasing_mortgage(record)
+        expect(record.errors["mortgage"]).to be_empty
+        expect(record.errors["value"]).to be_empty
+        expect(record.errors["deposit"]).to be_empty
+        expect(record.errors["equity"]).to be_empty
+        expect(record.errors["cashdis"]).to be_empty
+        expect(record.errors["type"]).to be_empty
       end
+    end
 
-      context "when mortgage is not used" do
-        before do
-          record.mortgageused = 2
-        end
+    context "when MORTGAGE + DEPOSIT is within 1£ tolerance of VALUE * EQUITY/100" do
+      let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 2, deposit: 50_000, value: 120_001, equity: 50, ownershipsch: 1, type: 30, saledate:) }
 
-        context "when DEPOSIT does not equal VALUE * EQUITY/100 " do
-          context "and it is not a staircase transaction" do
+      it "does not add an error" do
+        sale_information_validator.validate_non_staircasing_mortgage(record)
+        expect(record.errors["mortgage"]).to be_empty
+        expect(record.errors["value"]).to be_empty
+        expect(record.errors["deposit"]).to be_empty
+        expect(record.errors["equity"]).to be_empty
+        expect(record.errors["cashdis"]).to be_empty
+        expect(record.errors["type"]).to be_empty
+      end
+    end
+
+    context "when mortgage is not used" do
+      before do
+        record.mortgageused = 2
+      end
+
+      context "when DEPOSIT does not equal VALUE * EQUITY/100 " do
+        context "and it is not a staircase transaction" do
+          before do
+            record.staircase = 2
+          end
+
+          it "adds an error" do
+            sale_information_validator.validate_non_staircasing_mortgage(record)
+            expect(record.errors["mortgageused"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["value"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["deposit"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["equity"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["type"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
+            expect(record.errors["cashdis"]).not_to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
+          end
+
+          context "and it is a social homebuy" do
             before do
-              record.staircase = 2
+              record.type = 18
+              record.cashdis = "200"
             end
 
             it "adds an error" do
               sale_information_validator.validate_non_staircasing_mortgage(record)
-              expect(record.errors["mortgageused"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["value"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["deposit"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["equity"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["type"]).to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
-              expect(record.errors["cashdis"]).not_to include("The cash deposit is £5,000.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought is £8,400.00.</br></br>These two amounts should be the same.")
-            end
-
-            context "and it is a social homebuy" do
-              before do
-                record.type = 18
-                record.cashdis = "200"
-              end
-
-              it "adds an error" do
-                sale_information_validator.validate_non_staircasing_mortgage(record)
-                expect(record.errors["mortgageused"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-                expect(record.errors["value"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-                expect(record.errors["deposit"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-                expect(record.errors["equity"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-                expect(record.errors["cashdis"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-                expect(record.errors["type"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
-              end
-            end
-
-            context "and it is not a shared ownership transaction" do
-              before do
-                record.ownershipsch = 2
-              end
-
-              it "does not add an error" do
-                sale_information_validator.validate_non_staircasing_mortgage(record)
-                expect(record.errors["mortgageused"]).to be_empty
-                expect(record.errors["value"]).to be_empty
-                expect(record.errors["deposit"]).to be_empty
-                expect(record.errors["equity"]).to be_empty
-                expect(record.errors["cashdis"]).to be_empty
-                expect(record.errors["type"]).to be_empty
-              end
+              expect(record.errors["mortgageused"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+              expect(record.errors["value"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+              expect(record.errors["deposit"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+              expect(record.errors["equity"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+              expect(record.errors["cashdis"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
+              expect(record.errors["type"]).to include("The cash deposit (£5,000.00) and cash discount (£200.00) added together is £5,200.00.</br></br>The full purchase price (£30,000.00) multiplied by the percentage bought (28.0%) is £8,400.00.</br></br>These two amounts should be the same.")
             end
           end
 
-          context "and it is a staircase transaction" do
+          context "and it is not a shared ownership transaction" do
             before do
-              record.staircase = 1
+              record.ownershipsch = 2
             end
 
             it "does not add an error" do
@@ -1195,8 +1126,10 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
           end
         end
 
-        context "when DEPOSIT equals VALUE * EQUITY/100" do
-          let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 2, deposit: 15_000, value: 30_000, equity: 50, ownershipsch: 1, type: 30, saledate:) }
+        context "and it is a staircase transaction" do
+          before do
+            record.staircase = 1
+          end
 
           it "does not add an error" do
             sale_information_validator.validate_non_staircasing_mortgage(record)
@@ -1208,35 +1141,34 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
             expect(record.errors["type"]).to be_empty
           end
         end
+      end
 
-        context "when DEPOSIT is within 1£ tolerance of VALUE * EQUITY/100" do
-          let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 2, deposit: 15_000, value: 30_001, equity: 50, ownershipsch: 1, type: 30, saledate:) }
+      context "when DEPOSIT equals VALUE * EQUITY/100" do
+        let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 2, deposit: 15_000, value: 30_000, equity: 50, ownershipsch: 1, type: 30, saledate:) }
 
-          it "does not add an error" do
-            sale_information_validator.validate_non_staircasing_mortgage(record)
-            expect(record.errors["mortgageused"]).to be_empty
-            expect(record.errors["value"]).to be_empty
-            expect(record.errors["deposit"]).to be_empty
-            expect(record.errors["equity"]).to be_empty
-            expect(record.errors["cashdis"]).to be_empty
-            expect(record.errors["type"]).to be_empty
-          end
+        it "does not add an error" do
+          sale_information_validator.validate_non_staircasing_mortgage(record)
+          expect(record.errors["mortgageused"]).to be_empty
+          expect(record.errors["value"]).to be_empty
+          expect(record.errors["deposit"]).to be_empty
+          expect(record.errors["equity"]).to be_empty
+          expect(record.errors["cashdis"]).to be_empty
+          expect(record.errors["type"]).to be_empty
         end
       end
-    end
 
-    context "when it is a 2023 log" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
-      let(:record) { FactoryBot.build(:sales_log, mortgage: 10_000, staircase: 2, deposit: 5_000, value: 30_000, equity: 28, ownershipsch: 1, type: 30, saledate:) }
+      context "when DEPOSIT is within 1£ tolerance of VALUE * EQUITY/100" do
+        let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 2, deposit: 15_000, value: 30_001, equity: 50, ownershipsch: 1, type: 30, saledate:) }
 
-      it "does not add an error" do
-        sale_information_validator.validate_non_staircasing_mortgage(record)
-        expect(record.errors["mortgage"]).to be_empty
-        expect(record.errors["value"]).to be_empty
-        expect(record.errors["deposit"]).to be_empty
-        expect(record.errors["equity"]).to be_empty
-        expect(record.errors["cashdis"]).to be_empty
-        expect(record.errors["type"]).to be_empty
+        it "does not add an error" do
+          sale_information_validator.validate_non_staircasing_mortgage(record)
+          expect(record.errors["mortgageused"]).to be_empty
+          expect(record.errors["value"]).to be_empty
+          expect(record.errors["deposit"]).to be_empty
+          expect(record.errors["equity"]).to be_empty
+          expect(record.errors["cashdis"]).to be_empty
+          expect(record.errors["type"]).to be_empty
+        end
       end
     end
   end
@@ -1244,65 +1176,47 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
   describe "#validate_staircasing_mortgage" do
     let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, deposit: 5_000, value: 30_000, stairbought: 28, ownershipsch: 1, type: 30, saledate:) }
 
-    context "with a log in the 24/25 collection year" do
-      let(:saledate) { Time.zone.local(2024, 4, 4) }
+    let(:saledate) { current_collection_start_date }
 
-      context "when MORTGAGE + DEPOSIT does not equal STAIRBOUGHT/100 * VALUE" do
-        context "and it is a staircase transaction" do
+    context "when MORTGAGE + DEPOSIT does not equal STAIRBOUGHT/100 * VALUE" do
+      context "and it is a staircase transaction" do
+        before do
+          record.staircase = 1
+        end
+
+        it "adds an error" do
+          sale_information_validator.validate_staircasing_mortgage(record)
+          expect(record.errors["mortgage"]).to include(I18n.t("validations.sales.sale_information.mortgage.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+          expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+          expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+          expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+          expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+        end
+
+        context "and it is a social homebuy" do
           before do
-            record.staircase = 1
+            record.type = 18
+            record.cashdis = "200"
           end
 
           it "adds an error" do
             sale_information_validator.validate_staircasing_mortgage(record)
-            expect(record.errors["mortgage"]).to include(I18n.t("validations.sales.sale_information.mortgage.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-            expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-            expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-            expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-            expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_used", mortgage: "£10,000.00", deposit: "£5,000.00", mortgage_and_deposit_total: "£15,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-          end
-
-          context "and it is a social homebuy" do
-            before do
-              record.type = 18
-              record.cashdis = "200"
-            end
-
-            it "adds an error" do
-              sale_information_validator.validate_staircasing_mortgage(record)
-              expect(record.errors["mortgage"]).to include(I18n.t("validations.sales.sale_information.mortgage.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
-              expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
-              expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
-              expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
-              expect(record.errors["cashdis"]).to include(I18n.t("validations.sales.sale_information.cashdis.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
-              expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
-            end
-          end
-
-          context "and it is not a shared ownership transaction" do
-            before do
-              record.ownershipsch = 2
-            end
-
-            it "does not add an error" do
-              sale_information_validator.validate_non_staircasing_mortgage(record)
-              expect(record.errors["mortgage"]).to be_empty
-              expect(record.errors["value"]).to be_empty
-              expect(record.errors["deposit"]).to be_empty
-              expect(record.errors["stairbought"]).to be_empty
-              expect(record.errors["cashdis"]).to be_empty
-              expect(record.errors["type"]).to be_empty
-            end
+            expect(record.errors["mortgage"]).to include(I18n.t("validations.sales.sale_information.mortgage.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
+            expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
+            expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
+            expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
+            expect(record.errors["cashdis"]).to include(I18n.t("validations.sales.sale_information.cashdis.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
+            expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_used_socialhomebuy", mortgage: "£10,000.00", deposit: "£5,000.00", cashdis: "£200.00", mortgage_deposit_and_discount_total: "£15,200.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00", stairbought: "28.0%"))
           end
         end
 
-        context "and it is not a staircase transaction" do
+        context "and it is not a shared ownership transaction" do
           before do
-            record.staircase = 2
+            record.ownershipsch = 2
           end
 
           it "does not add an error" do
-            sale_information_validator.validate_staircasing_mortgage(record)
+            sale_information_validator.validate_non_staircasing_mortgage(record)
             expect(record.errors["mortgage"]).to be_empty
             expect(record.errors["value"]).to be_empty
             expect(record.errors["deposit"]).to be_empty
@@ -1313,8 +1227,10 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
         end
       end
 
-      context "when MORTGAGE + DEPOSIT equals STAIRBOUGHT/100 * VALUE" do
-        let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 1, deposit: 5_000, value: 30_000, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
+      context "and it is not a staircase transaction" do
+        before do
+          record.staircase = 2
+        end
 
         it "does not add an error" do
           sale_information_validator.validate_staircasing_mortgage(record)
@@ -1326,25 +1242,24 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
           expect(record.errors["type"]).to be_empty
         end
       end
+    end
 
-      context "when MORTGAGE + DEPOSIT is within 1£ tolerance of STAIRBOUGHT/100 * VALUE" do
-        let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 1, deposit: 5_000, value: 30_001, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
+    context "when MORTGAGE + DEPOSIT equals STAIRBOUGHT/100 * VALUE" do
+      let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 1, deposit: 5_000, value: 30_000, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
 
-        it "does not add an error" do
-          sale_information_validator.validate_staircasing_mortgage(record)
-          expect(record.errors["mortgage"]).to be_empty
-          expect(record.errors["value"]).to be_empty
-          expect(record.errors["deposit"]).to be_empty
-          expect(record.errors["stairbought"]).to be_empty
-          expect(record.errors["cashdis"]).to be_empty
-          expect(record.errors["type"]).to be_empty
-        end
+      it "does not add an error" do
+        sale_information_validator.validate_staircasing_mortgage(record)
+        expect(record.errors["mortgage"]).to be_empty
+        expect(record.errors["value"]).to be_empty
+        expect(record.errors["deposit"]).to be_empty
+        expect(record.errors["stairbought"]).to be_empty
+        expect(record.errors["cashdis"]).to be_empty
+        expect(record.errors["type"]).to be_empty
       end
     end
 
-    context "when it is a 2023 log" do
-      let(:saledate) { Time.zone.local(2023, 4, 1) }
-      let(:record) { FactoryBot.build(:sales_log, mortgage: 10_000, staircase: 1, deposit: 5_000, value: 30_000, stairbought: 28, ownershipsch: 1, type: 30, saledate:) }
+    context "when MORTGAGE + DEPOSIT is within 1£ tolerance of STAIRBOUGHT/100 * VALUE" do
+      let(:record) { FactoryBot.build(:sales_log, mortgageused: 1, mortgage: 10_000, staircase: 1, deposit: 5_000, value: 30_001, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
 
       it "does not add an error" do
         sale_information_validator.validate_staircasing_mortgage(record)
@@ -1358,69 +1273,51 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
     end
 
     context "when mortgage is not used" do
-      context "with a log in the 24/25 collection year" do
-        let(:saledate) { Time.zone.local(2024, 4, 4) }
+      let(:saledate) { current_collection_start_date }
 
-        before do
-          record.mortgageused = 2
-        end
+      before do
+        record.mortgageused = 2
+      end
 
-        context "when DEPOSIT does not equal STAIRBOUGHT/100 * VALUE" do
-          context "and it is a staircase transaction" do
+      context "when DEPOSIT does not equal STAIRBOUGHT/100 * VALUE" do
+        context "and it is a staircase transaction" do
+          before do
+            record.staircase = 1
+          end
+
+          it "adds an error" do
+            sale_information_validator.validate_staircasing_mortgage(record)
+            expect(record.errors["mortgageused"]).to include(I18n.t("validations.sales.sale_information.mortgageused.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+            expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+            expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+            expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+            expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
+          end
+
+          context "and it is a social homebuy" do
             before do
-              record.staircase = 1
+              record.type = 18
+              record.cashdis = "200"
             end
 
             it "adds an error" do
               sale_information_validator.validate_staircasing_mortgage(record)
-              expect(record.errors["mortgageused"]).to include(I18n.t("validations.sales.sale_information.mortgageused.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-              expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-              expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-              expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-              expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_not_used", deposit: "£5,000.00", value: "£30,000.00", stairbought_part_of_value: "£8,400.00"))
-            end
-
-            context "and it is a social homebuy" do
-              before do
-                record.type = 18
-                record.cashdis = "200"
-              end
-
-              it "adds an error" do
-                sale_information_validator.validate_staircasing_mortgage(record)
-                expect(record.errors["mortgageused"]).to include(I18n.t("validations.sales.sale_information.mortgageused.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
-                expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
-                expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
-                expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
-                expect(record.errors["cashdis"]).to include(I18n.t("validations.sales.sale_information.cashdis.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
-                expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
-              end
-            end
-
-            context "and it is not a shared ownership transaction" do
-              before do
-                record.ownershipsch = 2
-              end
-
-              it "does not add an error" do
-                sale_information_validator.validate_non_staircasing_mortgage(record)
-                expect(record.errors["mortgageused"]).to be_empty
-                expect(record.errors["value"]).to be_empty
-                expect(record.errors["deposit"]).to be_empty
-                expect(record.errors["stairbought"]).to be_empty
-                expect(record.errors["cashdis"]).to be_empty
-                expect(record.errors["type"]).to be_empty
-              end
+              expect(record.errors["mortgageused"]).to include(I18n.t("validations.sales.sale_information.mortgageused.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
+              expect(record.errors["value"]).to include(I18n.t("validations.sales.sale_information.value.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
+              expect(record.errors["deposit"]).to include(I18n.t("validations.sales.sale_information.deposit.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
+              expect(record.errors["stairbought"]).to include(I18n.t("validations.sales.sale_information.stairbought.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
+              expect(record.errors["cashdis"]).to include(I18n.t("validations.sales.sale_information.cashdis.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
+              expect(record.errors["type"]).to include(I18n.t("validations.sales.sale_information.type.staircasing_mortgage.mortgage_not_used_socialhomebuy", deposit: "£5,000.00", cashdis: "£200.00", deposit_and_discount_total: "£5,200.00", value: "£30,000.00", stairbought: "28.0%", stairbought_part_of_value: "£8,400.00"))
             end
           end
 
-          context "and it is not a staircase transaction" do
+          context "and it is not a shared ownership transaction" do
             before do
-              record.staircase = 2
+              record.ownershipsch = 2
             end
 
             it "does not add an error" do
-              sale_information_validator.validate_staircasing_mortgage(record)
+              sale_information_validator.validate_non_staircasing_mortgage(record)
               expect(record.errors["mortgageused"]).to be_empty
               expect(record.errors["value"]).to be_empty
               expect(record.errors["deposit"]).to be_empty
@@ -1431,8 +1328,10 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
           end
         end
 
-        context "when DEPOSIT equals STAIRBOUGHT/100 * VALUE" do
-          let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 1, deposit: 15_000, value: 30_000, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
+        context "and it is not a staircase transaction" do
+          before do
+            record.staircase = 2
+          end
 
           it "does not add an error" do
             sale_information_validator.validate_staircasing_mortgage(record)
@@ -1444,25 +1343,24 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
             expect(record.errors["type"]).to be_empty
           end
         end
+      end
 
-        context "when DEPOSIT is within 1£ tolerance of STAIRBOUGHT/100 * VALUE" do
-          let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 1, deposit: 15_000, value: 30_001, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
+      context "when DEPOSIT equals STAIRBOUGHT/100 * VALUE" do
+        let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 1, deposit: 15_000, value: 30_000, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
 
-          it "does not add an error" do
-            sale_information_validator.validate_staircasing_mortgage(record)
-            expect(record.errors["mortgageused"]).to be_empty
-            expect(record.errors["value"]).to be_empty
-            expect(record.errors["deposit"]).to be_empty
-            expect(record.errors["stairbought"]).to be_empty
-            expect(record.errors["cashdis"]).to be_empty
-            expect(record.errors["type"]).to be_empty
-          end
+        it "does not add an error" do
+          sale_information_validator.validate_staircasing_mortgage(record)
+          expect(record.errors["mortgageused"]).to be_empty
+          expect(record.errors["value"]).to be_empty
+          expect(record.errors["deposit"]).to be_empty
+          expect(record.errors["stairbought"]).to be_empty
+          expect(record.errors["cashdis"]).to be_empty
+          expect(record.errors["type"]).to be_empty
         end
       end
 
-      context "when it is a 2023 log" do
-        let(:saledate) { Time.zone.local(2023, 4, 1) }
-        let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 1, deposit: 5_000, value: 30_000, stairbought: 28, ownershipsch: 1, type: 30, saledate:) }
+      context "when DEPOSIT is within 1£ tolerance of STAIRBOUGHT/100 * VALUE" do
+        let(:record) { FactoryBot.build(:sales_log, mortgageused: 2, staircase: 1, deposit: 15_000, value: 30_001, stairbought: 50, ownershipsch: 1, type: 30, saledate:) }
 
         it "does not add an error" do
           sale_information_validator.validate_staircasing_mortgage(record)
@@ -1501,21 +1399,8 @@ RSpec.describe Validations::Sales::SaleInformationValidations do
       context "and it is an outright sale" do
         let(:ownershipsch) { 3 }
 
-        context "with a saledate before 24/25" do
-          let(:saledate) { Time.zone.local(2023, 9, 9) }
-
-          it "adds errors" do
-            expect(sales_log.errors[:mortgageused]).to include "Enter a valid value for was a mortgage used for the purchase of this property?"
-            expect(sales_log.errors[:saledate]).to include "You must answer either ‘yes’ or ‘no’ to the question ‘was a mortgage used’ for the selected year."
-          end
-        end
-
-        context "with a saledate from 24/25 or after" do
-          let(:saledate) { Time.zone.today }
-
-          it "does not add any errors" do
-            expect(sales_log.errors).to be_empty
-          end
+        it "does not add any errors" do
+          expect(sales_log.errors).to be_empty
         end
       end
 
diff --git a/spec/models/validations/sales/soft_validations_spec.rb b/spec/models/validations/sales/soft_validations_spec.rb
index 51f0d695a..e943a38a4 100644
--- a/spec/models/validations/sales/soft_validations_spec.rb
+++ b/spec/models/validations/sales/soft_validations_spec.rb
@@ -1,6 +1,8 @@
 require "rails_helper"
 
 RSpec.describe Validations::Sales::SoftValidations do
+  include CollectionTimeHelper
+
   let(:record) { build(:sales_log) }
 
   describe "income validations" do
@@ -404,87 +406,16 @@ RSpec.describe Validations::Sales::SoftValidations do
     end
 
     context "when validating extra borrowing" do
-      context "when the log is for 2023" do
-        let(:record) { build(:sales_log, saledate: Time.zone.local(2023, 12, 1)) }
-
-        it "returns false if extrabor not present" do
-          record.mortgage = 50_000
-          record.deposit = 40_000
-          record.value = 100_000
-          record.discount = 11
-          expect(record)
-            .not_to be_extra_borrowing_expected_but_not_reported
-        end
-
-        it "returns false if mortgage not present" do
-          record.extrabor = 2
-          record.deposit = 40_000
-          record.value = 100_000
-          record.discount = 11
-          expect(record)
-            .not_to be_extra_borrowing_expected_but_not_reported
-        end
-
-        it "returns false if deposit not present" do
-          record.extrabor = 2
-          record.mortgage = 50_000
-          record.value = 100_000
-          record.discount = 11
-          expect(record)
-            .not_to be_extra_borrowing_expected_but_not_reported
-        end
-
-        it "returns false if value not present" do
-          record.extrabor = 2
-          record.mortgage = 50_000
-          record.deposit = 40_000
-          record.discount = 11
-          expect(record)
-            .not_to be_extra_borrowing_expected_but_not_reported
-        end
-
-        it "returns false if discount not present" do
-          record.extrabor = 2
-          record.mortgage = 50_000
-          record.deposit = 40_000
-          record.value = 100_000
-          expect(record)
-            .not_to be_extra_borrowing_expected_but_not_reported
-        end
-
-        it "returns false if extra borrowing expected and reported" do
-          record.extrabor = 1
-          record.mortgage = 50_000
-          record.deposit = 40_000
-          record.value = 100_000
-          record.discount = 11
-          expect(record)
-            .not_to be_extra_borrowing_expected_but_not_reported
-        end
-
-        it "returns true if extra borrowing expected but not reported" do
-          record.extrabor = 2
-          record.mortgage = 50_000
-          record.deposit = 40_000
-          record.value = 100_000
-          record.discount = 11
-          expect(record)
-            .to be_extra_borrowing_expected_but_not_reported
-        end
-      end
-
-      context "when the log is for 2024" do
-        let(:record) { build(:sales_log, saledate: Time.zone.local(2024, 12, 1)) }
-
-        it "returns false for logs from 2024 onwards" do
-          record.extrabor = 2
-          record.mortgage = 50_000
-          record.deposit = 40_000
-          record.value = 100_000
-          record.discount = 11
-          expect(record)
-            .not_to be_extra_borrowing_expected_but_not_reported
-        end
+      let(:record) { build(:sales_log, saledate: previous_collection_start_date) }
+
+      it "returns false for logs from 2024 onwards" do
+        record.extrabor = 2
+        record.mortgage = 50_000
+        record.deposit = 40_000
+        record.value = 100_000
+        record.discount = 11
+        expect(record)
+          .not_to be_extra_borrowing_expected_but_not_reported
       end
     end
   end