CLDC-2288 ensure derived answers cleared when renewal changed from yes to no (#1596)

* add a validation to prevent an inconsistent combination of values and tests for this validation

* show related method in diff

* remove comment

* extract reusable logic from SalesLogVariables to independent module

* update lettings log tests around derivations related to renewal

* refactor derivation logic to share functionality with sales logs where possible

* remove some tests which are now duplicated above, refactor tests using Jack's wonderful :change suggestion, add in tests about logic deriving vacdays that was not previously covered

* minor changes after tech review

app/models/derived_variables/lettings_log_variables.rb

@@ -1,4 +1,6 @@
 module DerivedVariables::LettingsLogVariables
+  include DerivedVariables::SharedLogic
+
   # renttype and unitletas values are different for intermediate rent (3 for renttype and 4 for unitletas)
   RENT_TYPE_MAPPING = {
     0 => 1, # "Social Rent"  =>  "Social Rent"
@@ -35,10 +37,12 @@ module DerivedVariables::LettingsLogVariables
   end
 
   def set_derived_fields!
+    clear_inapplicable_derived_values!
+    set_encoded_derived_values!(DEPENDENCIES)
+
     if rsnvac.present?
       self.newprop = has_first_let_vacancy_reason? ? 1 : 2
     end
-    self.incref = 1 if net_income_refused?
     self.renttype = RENT_TYPE_MAPPING[rent_type]
     self.lettype = get_lettype
     self.totchild = get_totchild
@@ -69,15 +73,9 @@ module DerivedVariables::LettingsLogVariables
     self.nocharge = household_charge&.zero? ? 1 : 0
     if is_renewal?
       self.underoccupation_benefitcap = 2 if collection_start_year == 2021
-      self.referral = 1
-      self.waityear = 2
-      self.offered = 0
       self.voiddate = startdate
-      self.first_time_property_let_as_social_housing = 0
-      self.rsnvac = 14
       self.unitletas = form.start_date.year >= 2023 ? UNITLETAS_MAPPING_23_24[rent_type] : UNITLETAS_MAPPING[rent_type]
       if is_general_needs?
-        # fixed term
         self.prevten = 32 if managing_organisation&.provider_type == "PRP"
         self.prevten = 30 if managing_organisation&.provider_type == "LA"
       end
@@ -109,6 +107,49 @@ module DerivedVariables::LettingsLogVariables
 
 private
 
+  DEPENDENCIES = [
+    {
+      conditions: {
+        renewal: 1,
+      },
+      derived_values: {
+        referral: 1,
+        waityear: 2,
+        offered: 0,
+        rsnvac: 14,
+        first_time_property_let_as_social_housing: 0,
+      },
+    },
+    {
+      conditions: {
+        net_income_known: 2,
+      },
+      derived_values: {
+        incref: 1,
+      },
+    },
+  ].freeze
+
+  def clear_inapplicable_derived_values!
+    reset_invalidated_derived_values!(DEPENDENCIES)
+    if (startdate_changed? || renewal_changed?) && (renewal_was == 1 && startdate_was&.between?(Time.zone.local(2021, 4, 1), Time.zone.local(2022, 3, 31)))
+      self.underoccupation_benefitcap = nil
+    end
+    if renewal_changed? && renewal_was == 1
+      self.voiddate = nil
+      self.unitletas = nil
+    end
+    if %w[PRP LA].include?(managing_organisation&.provider_type) &&
+        (needstype_changed? || renewal_changed?) &&
+        needstype_was == 1 && renewal_was == 1
+      self.prevten = nil
+    end
+    if needstype_changed? && needstype_was == 2
+      self.wchair = nil
+      self.location_id = nil
+    end
+  end
+
   def get_totelder
     ages = [age1, age2, age3, age4, age5, age6, age7, age8]
     ages.count { |x| !x.nil? && x >= 60 }

app/models/derived_variables/sales_log_variables.rb

@@ -1,6 +1,8 @@
 module DerivedVariables::SalesLogVariables
+  include DerivedVariables::SharedLogic
+
   def set_derived_fields!
-    reset_invalidated_derived_values!
+    reset_invalidated_derived_values!(DEPENDENCIES)
 
     self.ethnic = 17 if ethnic_refused?
     self.mscharge = nil if no_monthly_leasehold_charges?
@@ -30,7 +32,7 @@ module DerivedVariables::SalesLogVariables
       self.uprn_known = 0
     end
 
-    set_encoded_derived_values!
+    set_encoded_derived_values!(DEPENDENCIES)
   end
 
 private
@@ -73,30 +75,6 @@ private
     },
   ].freeze
 
-  def reset_invalidated_derived_values!
-    DEPENDENCIES.each do |dependency|
-      any_conditions_changed = dependency[:conditions].any? { |attribute, _value| send("#{attribute}_changed?") }
-      next unless any_conditions_changed
-
-      previously_in_derived_state = dependency[:conditions].all? { |attribute, value| send("#{attribute}_was") == value }
-      next unless previously_in_derived_state
-
-      dependency[:derived_values].each do |derived_attribute, _derived_value|
-        Rails.logger.debug("Cleared derived #{derived_attribute} value")
-        send("#{derived_attribute}=", nil)
-      end
-    end
-  end
-
-  def set_encoded_derived_values!
-    DEPENDENCIES.each do |dependency|
-      derivation_applies = dependency[:conditions].all? { |attribute, value| send(attribute) == value }
-      if derivation_applies
-        dependency[:derived_values].each { |attribute, value| send("#{attribute}=", value) }
-      end
-    end
-  end
-
   def number_of_household_members
     return unless hholdcount.present? && jointpur.present?
 

app/models/derived_variables/shared_logic.rb

@@ -0,0 +1,27 @@
+module DerivedVariables::SharedLogic
+private
+
+  def reset_invalidated_derived_values!(dependencies)
+    dependencies.each do |dependency|
+      any_conditions_changed = dependency[:conditions].any? { |attribute, _value| send("#{attribute}_changed?") }
+      next unless any_conditions_changed
+
+      previously_in_derived_state = dependency[:conditions].all? { |attribute, value| send("#{attribute}_was") == value }
+      next unless previously_in_derived_state
+
+      dependency[:derived_values].each do |derived_attribute, _derived_value|
+        Rails.logger.debug("Cleared derived #{derived_attribute} value")
+        send("#{derived_attribute}=", nil)
+      end
+    end
+  end
+
+  def set_encoded_derived_values!(dependencies)
+    dependencies.each do |dependency|
+      derivation_applies = dependency[:conditions].all? { |attribute, value| send(attribute) == value }
+      if derivation_applies
+        dependency[:derived_values].each { |attribute, value| send("#{attribute}=", value) }
+      end
+    end
+  end
+end

app/models/lettings_log.rb

@@ -531,24 +531,6 @@ class LettingsLog < Log
 
 private
 
-  def reset_derived_questions
-    dependent_questions = { waityear: [{ key: :renewal, value: 0 }],
-                            referral: [{ key: :renewal, value: 0 }],
-                            rsnvac: [{ key: :renewal, value: 0 }],
-                            underoccupation_benefitcap: [{ key: :renewal, value: 0 }],
-                            wchair: [{ key: :needstype, value: 1 }],
-                            location_id: [{ key: :needstype, value: 1 }] }
-
-    dependent_questions.each do |dependent, conditions|
-      condition_key = conditions.first[:key]
-      condition_value = conditions.first[:value]
-      if public_send("#{condition_key}_changed?") && condition_value == public_send(condition_key) && !public_send("#{dependent}_changed?")
-        Rails.logger.debug("Cleared derived #{dependent} value")
-        self[dependent] = nil
-      end
-    end
-  end
-
   def reset_invalid_unresolved_log_fields!
     return unless unresolved?
 
@@ -581,7 +563,6 @@ private
 
     reset_invalid_unresolved_log_fields!
     reset_scheme
-    reset_derived_questions
   end
 
   def dynamically_not_required

spec/models/lettings_log_spec.rb

@@ -268,13 +268,6 @@ RSpec.describe LettingsLog do
       expect(record_from_db["mrcdate"].year).to eq(2021)
     end
 
-    it "correctly derives and saves partial and full major property void date" do
-      record_from_db = ActiveRecord::Base.connection.execute("select voiddate from lettings_logs where id=#{lettings_log.id}").to_a[0]
-      expect(record_from_db["voiddate"].day).to eq(3)
-      expect(record_from_db["voiddate"].month).to eq(3)
-      expect(record_from_db["voiddate"].year).to eq(2021)
-    end
-
     it "correctly derives and saves incref" do
       record_from_db = ActiveRecord::Base.connection.execute("select incref from lettings_logs where id=#{lettings_log.id}").to_a[0]
       expect(record_from_db["incref"]).to eq(1)
@@ -1504,334 +1497,329 @@ RSpec.describe LettingsLog do
       expect(record_from_db["has_benefits"]).to eq(1)
     end
 
-    context "when it is a renewal" do
+    context "when updating values that derive vacdays" do
+      let(:lettings_log) { create(:lettings_log, startdate:) }
+
+      context "when start date is set" do
+        let(:startdate) { Time.zone.now }
+
+        it "correctly derives vacdays when voiddate is set" do
+          day_count = 3
+          expect { lettings_log.update!(voiddate: startdate - day_count.days) }.to change(lettings_log, :vacdays).to day_count
+          expect { lettings_log.update!(voiddate: nil) }.to change(lettings_log, :vacdays).from(day_count).to nil
+        end
+
+        it "correctly derives vacdays when mrcdate is set" do
+          day_count = 3
+          expect { lettings_log.update!(mrcdate: startdate - day_count.days) }.to change(lettings_log, :vacdays).to day_count
+          expect { lettings_log.update!(mrcdate: nil) }.to change(lettings_log, :vacdays).from(day_count).to nil
+        end
+      end
+
+      context "when start date is not set" do
+        let(:startdate) { nil }
+
+        it "correctly derives vacdays when voiddate is set" do
+          day_count = 3
+          lettings_log.update!(voiddate: Time.zone.now - day_count.days)
+          expect(lettings_log.vacdays).to be nil
+        end
+
+        it "correctly derives vacdays when mrcdate is set" do
+          day_count = 3
+          lettings_log.update!(mrcdate: Time.zone.now - day_count.days)
+          expect(lettings_log.vacdays).to be nil
+        end
+      end
+    end
+
+    context "when updating renewal" do
       let!(:lettings_log) do
         described_class.create({
           managing_organisation: owning_organisation,
           owning_organisation:,
           created_by: created_by_user,
-          renewal: 1,
           startdate: Time.zone.local(2021, 4, 10),
           created_at: Time.utc(2022, 2, 8, 16, 52, 15),
         })
       end
 
-      it "correctly derives and saves waityear" do
+      it "correctly derives the length of time on local authority waiting list" do
-        record_from_db = ActiveRecord::Base.connection.execute("select waityear from lettings_logs where id=#{lettings_log.id}").to_a[0]
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :waityear).to 2
-        expect(record_from_db["waityear"]).to eq(2)
+        expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :waityear).from(2).to nil
-        expect(lettings_log["waityear"]).to eq(2)
       end
 
-      it "correctly derives and saves underoccupation_benefitcap if year is 2021" do
+      it "correctly derives the number of times previously offered since becoming available" do
-        record_from_db = ActiveRecord::Base.connection.execute("select underoccupation_benefitcap from lettings_logs where id=#{lettings_log.id}").to_a[0]
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :offered).to 0
-        expect(record_from_db["underoccupation_benefitcap"]).to eq(2)
+        expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :offered).from(0).to nil
-        expect(lettings_log["underoccupation_benefitcap"]).to eq(2)
       end
 
-      it "correctly derives and saves prevten" do
+      it "correctly derives referral if the letting is a renewal and clears it if it is not" do
-        lettings_log.managing_organisation.update!({ provider_type: "PRP" })
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :referral).to 1
-        lettings_log.update!({ needstype: 1 })
+        expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :referral).from(1).to nil
-
+      end
-        record_from_db = ActiveRecord::Base.connection.execute("select prevten from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["prevten"]).to eq(32)
-        expect(lettings_log["prevten"]).to eq(32)
 
-        lettings_log.managing_organisation.update!({ provider_type: "LA" })
+      it "correctly derives voiddate if the letting is a renewal and clears it if it is not" do
-        lettings_log.update!({ needstype: 1 })
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :voiddate).to lettings_log.startdate
+        expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :voiddate).from(lettings_log.startdate).to nil
+      end
 
-        record_from_db = ActiveRecord::Base.connection.execute("select prevten from lettings_logs where id=#{lettings_log.id}").to_a[0]
+      it "correctly derives first_time_property_let_as_social_housing and clears it if it is not" do
-        expect(record_from_db["prevten"]).to eq(30)
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :first_time_property_let_as_social_housing).to 0
-        expect(lettings_log["prevten"]).to eq(30)
+        expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :first_time_property_let_as_social_housing).from(0).to nil
       end
 
-      it "correctly derives and saves referral" do
+      it "correctly derives vacancy reason and clears it if it is not" do
-        record_from_db = ActiveRecord::Base.connection.execute("select referral from lettings_logs where id=#{lettings_log.id}").to_a[0]
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :rsnvac).to 14
-        expect(record_from_db["referral"]).to eq(1)
+        expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :rsnvac).from(14).to nil
-        expect(lettings_log["referral"]).to eq(1)
       end
 
-      it "correctly derives and saves vacdays" do
+      it "derives vacdays as 0 if log is renewal" do
-        record_from_db = ActiveRecord::Base.connection.execute("select vacdays from lettings_logs where id=#{lettings_log.id}").to_a[0]
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :vacdays).to 0
-        expect(record_from_db["vacdays"]).to eq(0)
-        expect(lettings_log["vacdays"]).to eq(0)
       end
 
-      it "correctly derives and saves first_time_property_let_as_social_housing" do
+      it "correctly derives underoccupation_benefitcap if log is a renewal from 2021/22" do
-        record_from_db = ActiveRecord::Base.connection.execute(
+        lettings_log.update!(renewal: 1)
-          "select first_time_property_let_as_social_housing" \
+        expect(lettings_log.underoccupation_benefitcap).to be 2
-          " from lettings_logs where id=#{lettings_log.id}",
-        ).to_a[0]
-        expect(record_from_db["first_time_property_let_as_social_housing"]).to eq(0)
-        expect(lettings_log["first_time_property_let_as_social_housing"]).to eq(0)
       end
 
-      it "derives vacancy reason as relet" do
+      it "clears underoccupation_benefitcap if log is no longer a renewal" do
-        record_from_db = ActiveRecord::Base.connection.execute("select rsnvac from lettings_logs where id=#{lettings_log.id}").to_a[0]
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :underoccupation_benefitcap).to 2
-        expect(record_from_db["rsnvac"]).to eq(14)
+        expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :underoccupation_benefitcap).from(2).to nil
-        expect(lettings_log["rsnvac"]).to eq(14)
       end
 
-      context "when deriving renttype and unitletas" do
+      it "clears underoccupation_benefitcap if log is no longer in 2021/22" do
-        before do
+        expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :underoccupation_benefitcap).to 2
-          Timecop.freeze(Time.zone.local(2022, 1, 1))
+        Timecop.return
-          allow(FeatureToggle).to receive(:startdate_two_week_validation_enabled?).and_return(false)
+        expect { lettings_log.update!(startdate: Time.zone.local(2023, 1, 1)) }.to change(lettings_log, :underoccupation_benefitcap).from(2).to nil
-          lettings_log.update!(rent_type:, irproduct_other: "other")
+      end
-        end
 
-        after do
+      context "when the log is general needs" do
-          Timecop.unfreeze
+        context "and the managing organisation is a private registered provider" do
-        end
+          before do
+            lettings_log.managing_organisation.update!(provider_type: "PRP")
+            lettings_log.update!(needstype: 1, renewal: 1)
+          end
 
-        context "when the rent_type is Social Rent (0)" do
+          it "correctly derives prevten" do
-          let(:rent_type) { 0 }
+            expect(lettings_log.prevten).to be 32
+          end
 
-          it "derives and saves renttype and unitletas as Social rent(1)" do
+          it "clears prevten if the log is marked as supported housing" do
-            record_from_db = ActiveRecord::Base.connection.execute("select renttype from lettings_logs where id=#{lettings_log.id}").to_a[0]
+            lettings_log.update!(needstype: 2)
-            expect(lettings_log.renttype).to eq(1)
+            expect(lettings_log.prevten).to be nil
-            expect(record_from_db["renttype"]).to eq(1)
           end
 
-          it "derives and saves unitletas as Social rent(1)" do
+          it "clears prevten if renewal is update to no" do
-            record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+            lettings_log.update!(renewal: 0)
-            expect(lettings_log.unitletas).to eq(1)
+            expect(lettings_log.prevten).to be nil
-            expect(record_from_db["unitletas"]).to eq(1)
           end
+        end
 
-          context "and it is a 23/24 form" do
+        context "and the managing organisation is a local authority" do
-            before do
+          before do
-              Timecop.freeze(Time.zone.local(2023, 5, 1))
+            lettings_log.managing_organisation.update!(provider_type: "LA")
-            end
+            lettings_log.update!(needstype: 1, renewal: 1)
+          end
 
-            after do
+          it "correctly derives prevten" do
-              Timecop.unfreeze
+            expect(lettings_log.prevten).to be 30
-            end
+          end
 
-            around do |example|
+          it "clears prevten if the log is marked as supported housing" do
-              Timecop.freeze(Time.zone.local(2023, 5, 1)) do
+            expect { lettings_log.update!(needstype: 2) }.to change(lettings_log, :prevten).to nil
-                Singleton.__init__(FormHandler)
+          end
-                example.run
-              end
-              Timecop.return
-              Singleton.__init__(FormHandler)
-            end
 
-            it "derives and saves unitletas as Social rent(1)" do
+          it "clears prevten if renewal is update to no" do
-              lettings_log.update!(startdate: Time.zone.local(2023, 5, 1))
+            expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :prevten).to nil
-              record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
-              expect(lettings_log.unitletas).to eq(1)
-              expect(record_from_db["unitletas"]).to eq(1)
-            end
           end
         end
+      end
 
-        context "when the rent_type is Affordable Rent(1)" do
+      context "and updating rent_type" do
-          let(:rent_type) { 1 }
+        let(:irproduct_other) { nil }
 
-          it "derives and saves renttype as Affordable Rent(2)" do
+        around do |example|
-            record_from_db = ActiveRecord::Base.connection.execute("select renttype from lettings_logs where id=#{lettings_log.id}").to_a[0]
+          Timecop.freeze(now) do
-            expect(lettings_log.renttype).to eq(2)
+            Singleton.__init__(FormHandler)
-            expect(record_from_db["renttype"]).to eq(2)
+            lettings_log.update!(rent_type:, irproduct_other:, startdate: now)
+            example.run
           end
+        end
 
-          it "derives and saves unitletas as Affordable Rent(2)" do
+        context "when collection year is 2022/23 or earlier" do
-            record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+          let(:now) { Time.zone.local(2023, 1, 1) }
-            expect(lettings_log.unitletas).to eq(2)
-            expect(record_from_db["unitletas"]).to eq(2)
-          end
 
-          context "and it is a 23/24 form" do
+          context "when rent_type is Social Rent" do
-            before do
+            let(:rent_type) { 0 }
-              Timecop.freeze(Time.zone.local(2023, 5, 1))
-            end
 
-            after do
+            it "derives the most recent let type as Social Rent basis if it is a renewal and clears it if it is not" do
-              Timecop.unfreeze
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 1
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(1).to nil
             end
+          end
 
-            around do |example|
+          context "when rent_type is Affordable Rent" do
-              Timecop.freeze(Time.zone.local(2023, 5, 1)) do
+            let(:rent_type) { 1 }
-                Singleton.__init__(FormHandler)
-                example.run
-              end
-              Timecop.return
-              Singleton.__init__(FormHandler)
-            end
 
-            it "derives and saves unitletas as Affordable Rent basis(2)" do
+            it "derives the most recent let type as Affordable Rent basis if it is a renewal and clears it if it is not" do
-              lettings_log.update!(startdate: Time.zone.local(2023, 5, 1))
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 2
-              record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(2).to nil
-              expect(lettings_log.unitletas).to eq(2)
-              expect(record_from_db["unitletas"]).to eq(2)
             end
           end
-        end
 
-        context "when the rent_type is London Affordable Rent(2)" do
+          context "when rent_type is London Affordable Rent" do
-          let(:rent_type) { 2 }
+            let(:rent_type) { 2 }
 
-          it "derives and saves renttype as London Affordable Rent(2)" do
+            it "derives the most recent let type as Affordable Rent basis if it is a renewal and clears it if it is not" do
-            record_from_db = ActiveRecord::Base.connection.execute("select renttype from lettings_logs where id=#{lettings_log.id}").to_a[0]
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 2
-            expect(lettings_log.renttype).to eq(2)
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(2).to nil
-            expect(record_from_db["renttype"]).to eq(2)
+            end
           end
 
-          it "derives and saves unitletas as London Affordable Rent(2)" do
+          context "when rent_type is Rent to Buy" do
-            record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+            let(:rent_type) { 3 }
-            expect(lettings_log.unitletas).to eq(2)
-            expect(record_from_db["unitletas"]).to eq(2)
-          end
 
-          context "and it is a 23/24 form" do
+            it "derives the most recent let type as Intermediate Rent basis if it is a renewal and clears it if it is not" do
-            before do
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 4
-              Timecop.freeze(Time.zone.local(2023, 5, 1))
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(4).to nil
             end
+          end
 
-            after do
+          context "when rent_type is London Living Rent" do
-              Timecop.unfreeze
+            let(:rent_type) { 4 }
-            end
 
-            around do |example|
+            it "derives the most recent let type as Intermediate Rent basis if it is a renewal and clears it if it is not" do
-              Timecop.freeze(Time.zone.local(2023, 5, 1)) do
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 4
-                Singleton.__init__(FormHandler)
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(4).to nil
-                example.run
-              end
-              Timecop.return
-              Singleton.__init__(FormHandler)
             end
+          end
+
+          context "when rent_type is Other intermediate rent product" do
+            let(:rent_type) { 5 }
+            let(:irproduct_other) { "Rent first" }
 
-            it "derives and saves unitletas as London Affordable Rent basis(5)" do
+            it "derives the most recent let type as Intermediate Rent basis if it is a renewal and clears it if it is not" do
-              lettings_log.update!(startdate: Time.zone.local(2023, 5, 1))
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 4
-              record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(4).to nil
-              expect(lettings_log.unitletas).to eq(5)
-              expect(record_from_db["unitletas"]).to eq(5)
             end
           end
         end
 
-        context "when the rent_type is Rent to Buy(3)" do
+        context "when collection year is 2023/24 or later" do
-          let(:rent_type) { 3 }
+          let(:now) { Time.zone.local(2024, 1, 1) }
 
-          it "derives and saves renttype as Intermediate Rent(3)" do
+          context "when rent_type is Social Rent" do
-            record_from_db = ActiveRecord::Base.connection.execute("select renttype from lettings_logs where id=#{lettings_log.id}").to_a[0]
+            let(:rent_type) { 0 }
-            expect(lettings_log.renttype).to eq(3)
-            expect(record_from_db["renttype"]).to eq(3)
-          end
 
-          it "derives and saves unitletas as Intermediate Rent(4)" do
+            it "derives the most recent let type as Social Rent basis if it is a renewal and clears it if it is not" do
-            record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 1
-            expect(lettings_log.unitletas).to eq(4)
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(1).to nil
-            expect(record_from_db["unitletas"]).to eq(4)
+            end
           end
 
-          context "and it is a 23/24 form" do
+          context "when rent_type is Affordable Rent" do
-            before do
+            let(:rent_type) { 1 }
-              Timecop.freeze(Time.zone.local(2023, 5, 1))
-            end
 
-            after do
+            it "derives the most recent let type as Affordable Rent basis if it is a renewal and clears it if it is not" do
-              Timecop.unfreeze
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 2
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(2).to nil
             end
+          end
 
-            around do |example|
+          context "when rent_type is London Affordable Rent" do
-              Timecop.freeze(Time.zone.local(2023, 5, 1)) do
+            let(:rent_type) { 2 }
-                Singleton.__init__(FormHandler)
-                example.run
-              end
-              Timecop.return
-              Singleton.__init__(FormHandler)
-            end
 
-            it "derives and saves unitletas as Rent to Buy basis(6)" do
+            it "derives the most recent let type as London Affordable Rent basis if it is a renewal and clears it if it is not" do
-              lettings_log.update!(startdate: Time.zone.local(2023, 5, 1))
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 5
-              record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(5).to nil
-              expect(lettings_log.unitletas).to eq(6)
-              expect(record_from_db["unitletas"]).to eq(6)
             end
           end
-        end
 
-        context "when the rent_type is London Living Rent(4)" do
+          context "when rent_type is Rent to Buy" do
-          let(:rent_type) { 4 }
+            let(:rent_type) { 3 }
 
-          it "derives and saves renttype as Intermediate Rent(3)" do
+            it "derives the most recent let type as Rent to Buy basis if it is a renewal and clears it if it is not" do
-            record_from_db = ActiveRecord::Base.connection.execute("select renttype from lettings_logs where id=#{lettings_log.id}").to_a[0]
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 6
-            expect(lettings_log.renttype).to eq(3)
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(6).to nil
-            expect(record_from_db["renttype"]).to eq(3)
+            end
-          end
-
-          it "derives and saves unitletas as Intermediate Rent(4)" do
-            record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
-            expect(lettings_log.unitletas).to eq(4)
-            expect(record_from_db["unitletas"]).to eq(4)
           end
 
-          context "and it is a 23/24 form" do
+          context "when rent_type is London Living Rent" do
-            before do
+            let(:rent_type) { 4 }
-              Timecop.freeze(Time.zone.local(2023, 5, 1))
-            end
 
-            after do
+            it "derives the most recent let type as London Living Rent basis if it is a renewal and clears it if it is not" do
-              Timecop.unfreeze
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 7
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(7).to nil
             end
+          end
 
-            around do |example|
+          context "when rent_type is Other intermediate rent product" do
-              Timecop.freeze(Time.zone.local(2023, 5, 1)) do
+            let(:rent_type) { 5 }
-                Singleton.__init__(FormHandler)
+            let(:irproduct_other) { "Rent first" }
-                example.run
-              end
-              Timecop.return
-              Singleton.__init__(FormHandler)
-            end
 
-            it "derives and saves unitletas as London Living Rent basis(7)" do
+            it "derives the most recent let type as Another Intermediate Rent basis if it is a renewal and clears it if it is not" do
-              lettings_log.update!(startdate: Time.zone.local(2023, 5, 1))
+              expect { lettings_log.update!(renewal: 1) }.to change(lettings_log, :unitletas).to 8
-              record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+              expect { lettings_log.update!(renewal: 0) }.to change(lettings_log, :unitletas).from(8).to nil
-              expect(lettings_log.unitletas).to eq(7)
-              expect(record_from_db["unitletas"]).to eq(7)
             end
           end
         end
+      end
+    end
+
+    context "when updating rent type" do
+      let(:irproduct_other) { nil }
+
+      before do
+        lettings_log.update!(rent_type:, irproduct_other:)
+      end
+
+      context "when rent_type is Social Rent" do
+        let(:rent_type) { 0 }
+
+        it "derives renttype as Social Rent" do
+          expect(lettings_log.renttype).to be 1
+        end
+      end
 
-        context "when the rent_type is Other intermediate rent product(5)" do
+      context "when rent_type is Affordable Rent" do
-          let(:rent_type) { 5 }
+        let(:rent_type) { 1 }
 
-          it "derives and saves renttype as Intermediate Rent(3)" do
+        it "derives renttype as Affordable Rent" do
-            record_from_db = ActiveRecord::Base.connection.execute("select renttype from lettings_logs where id=#{lettings_log.id}").to_a[0]
+          expect(lettings_log.renttype).to be 2
-            expect(lettings_log.renttype).to eq(3)
+        end
-            expect(record_from_db["renttype"]).to eq(3)
+      end
-          end
 
-          it "derives and saves unitletas as Intermediate Rent(4)" do
+      context "when rent_type is London Affordable Rent" do
-            record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+        let(:rent_type) { 2 }
-            expect(lettings_log.unitletas).to eq(4)
-            expect(record_from_db["unitletas"]).to eq(4)
-          end
 
-          context "and it is a 23/24 form" do
+        it "derives renttype as Affordable Rent" do
-            before do
+          expect(lettings_log.renttype).to be 2
-              Timecop.freeze(Time.zone.local(2023, 5, 1))
+        end
-            end
+      end
 
-            after do
+      context "when rent_type is Rent to Buy" do
-              Timecop.unfreeze
+        let(:rent_type) { 3 }
-            end
 
-            around do |example|
+        it "derives renttype as Intermediate Rent" do
-              Timecop.freeze(Time.zone.local(2023, 5, 1)) do
+          expect(lettings_log.renttype).to be 3
-                Singleton.__init__(FormHandler)
+        end
-                example.run
+      end
-              end
-              Timecop.return
-              Singleton.__init__(FormHandler)
-            end
 
-            it "derives and saves unitletas as Other intermediate rent basis(8)" do
+      context "when rent_type is London Living Rent" do
-              lettings_log.update!(startdate: Time.zone.local(2023, 5, 1))
+        let(:rent_type) { 4 }
-              record_from_db = ActiveRecord::Base.connection.execute("select unitletas from lettings_logs where id=#{lettings_log.id}").to_a[0]
+
-              expect(lettings_log.unitletas).to eq(8)
+        it "derives renttype as Intermediate Rent" do
-              expect(record_from_db["unitletas"]).to eq(8)
+          expect(lettings_log.renttype).to be 3
-            end
+        end
-          end
+      end
+
+      context "when rent_type is Other intermediate rent product" do
+        let(:rent_type) { 5 }
+        let(:irproduct_other) { "Rent first" }
+
+        it "derives renttype as Intermediate Rent" do
+          expect(lettings_log.renttype).to be 3
         end
       end
     end
@@ -2168,37 +2156,6 @@ RSpec.describe LettingsLog do
           expect(record_from_db["wchair"]).to eq(1)
         end
       end
-
-      context "and renewal" do
-        before do
-          Timecop.freeze(Time.zone.local(2022, 4, 2))
-        end
-
-        after do
-          Timecop.unfreeze
-        end
-
-        let(:scheme) { create(:scheme) }
-        let(:location) { create(:location, scheme:) }
-        let!(:supported_housing_lettings_log) do
-          described_class.create!({
-            managing_organisation: owning_organisation,
-            owning_organisation:,
-            created_by: created_by_user,
-            needstype: 2,
-            scheme_id: scheme.id,
-            location_id: location.id,
-            renewal: 1,
-            startdate: Time.zone.local(2022, 4, 2),
-            created_at: Time.utc(2022, 2, 8, 16, 52, 15),
-          })
-        end
-
-        it "correctly infers and saves the renewal date" do
-          record_from_db = ActiveRecord::Base.connection.execute("SELECT voiddate from lettings_logs where id=#{supported_housing_lettings_log.id}").to_a[0]
-          expect(record_from_db["voiddate"].to_i).to eq(supported_housing_lettings_log.startdate.to_i)
-        end
-      end
     end
 
     context "when saving accessibility needs" do
@@ -2434,77 +2391,18 @@ RSpec.describe LettingsLog do
       end
     end
 
-    context "when it changes from a renewal to not a renewal" do
-      let(:lettings_log) { create(:lettings_log) }
-
-      it "resets inferred waityear value" do
-        lettings_log.update!({ renewal: 1 })
-
-        record_from_db = ActiveRecord::Base.connection.execute("select waityear from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["waityear"]).to eq(2)
-        expect(lettings_log["waityear"]).to eq(2)
-
-        lettings_log.update!({ renewal: 0 })
-        record_from_db = ActiveRecord::Base.connection.execute("select waityear from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["waityear"]).to eq(nil)
-        expect(lettings_log["waityear"]).to eq(nil)
-      end
-
-      it "resets inferred vacancy reason value" do
-        vacancy_reason = "rsnvac"
-
-        lettings_log.update!({ renewal: 1 })
-
-        record_from_db = ActiveRecord::Base.connection.execute("select #{vacancy_reason} from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db[vacancy_reason]).to eq(14)
-        expect(lettings_log[vacancy_reason]).to eq(14)
-
-        lettings_log.update!({ renewal: 0 })
-        record_from_db = ActiveRecord::Base.connection.execute("select #{vacancy_reason} from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db[vacancy_reason]).to eq(nil)
-        expect(lettings_log[vacancy_reason]).to eq(nil)
-      end
-    end
-
     context "when it changes from a supported housing to not a supported housing" do
       let(:location) { create(:location, mobility_type: "A", postcode: "SW1P 4DG") }
       let(:lettings_log) { create(:lettings_log, location:) }
 
       it "resets inferred wchair value" do
-        lettings_log.update!({ needstype: 2 })
+        expect { lettings_log.update!(needstype: 2) }.to change(lettings_log, :wchair).to(2)
-
+        expect { lettings_log.update!(needstype: 1) }.to change(lettings_log, :wchair).from(2).to(nil)
-        record_from_db = ActiveRecord::Base.connection.execute("select wchair from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["wchair"]).to eq(2)
-        expect(lettings_log["wchair"]).to eq(2)
-
-        lettings_log.update!({ needstype: 1 })
-        record_from_db = ActiveRecord::Base.connection.execute("select needstype from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["wchair"]).to eq(nil)
-        expect(lettings_log["wchair"]).to eq(nil)
       end
 
       it "resets location" do
-        lettings_log.update!({ needstype: 2 })
+        lettings_log.update!(needstype: 2)
-
+        expect { lettings_log.update!(needstype: 1) }.to change(lettings_log, :location_id).from(location.id).to(nil)
-        record_from_db = ActiveRecord::Base.connection.execute("select location_id from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["location_id"]).to eq(location.id)
-        expect(lettings_log["location_id"]).to eq(location.id)
-        lettings_log.update!({ needstype: 1 })
-        record_from_db = ActiveRecord::Base.connection.execute("select location_id from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["location_id"]).to eq(nil)
-        expect(lettings_log["location_id"]).to eq(nil)
-      end
-    end
-
-    context "when it is not a renewal" do
-      let(:lettings_log) { create(:lettings_log) }
-
-      it "saves waityear value" do
-        lettings_log.update!({ renewal: 0, waityear: 2 })
-
-        record_from_db = ActiveRecord::Base.connection.execute("select waityear from lettings_logs where id=#{lettings_log.id}").to_a[0]
-        expect(record_from_db["waityear"]).to eq(2)
-        expect(lettings_log["waityear"]).to eq(2)
       end
     end