Remove the :prefill validation context

Prefill input is now fully screened by the PrefillTypeDeChamp classes,
so champs no longer need to validate under a :prefill context:

- PrefillChamps::PrefillValue no longer assigns attributes to run
  champ.valid?(:prefill); prefillable? only checks that screening
  produced attributes.
- ChampValidateConcern drops the :prefill branch.
- DossierLinkChamp drops the prefill-only value_integerable validation.
- PaysChamp drops its stricter prefill-only inclusion validations.
- DateChamp converts its guarded before_validation into normalizes,
  for symmetry with DatetimeChamp.

Since screening no longer mutates the champ, a rejected prefill value
can no longer leak to the database through the dossier champ_data
autosave; a regression spec covers this.

Author: tchak

app/models/champs/date_champ.rb

@@ -4,7 +4,7 @@ class Champs::DateChamp < Champ
   attr_accessor :prefilling_from_france_connect_information
 
   validates_with DateLimitValidator, if: :should_validate_in_current_context?
-  before_validation :convert_to_iso8601_date, unless: -> { validation_context == :prefill }
+  normalizes :value, with: -> { DateDetectionUtils.convert_to_iso8601_date(it) }
   before_save :clear_prefilled_from_france_connect_information_flag_if_modified
   validate :iso_8601
 
@@ -22,10 +22,6 @@ def clear_prefilled_from_france_connect_information_flag_if_modified
     data.delete("prefilled_from_france_connect_information")
   end
 
-  def convert_to_iso8601_date
-    self.value = DateDetectionUtils.convert_to_iso8601_date(value)
-  end
-
   def iso_8601
     return if DateDetectionUtils.parsable_iso8601_date?(value) || value.blank?
 

app/models/champs/dossier_link_champ.rb

@@ -1,14 +1,5 @@
 # frozen_string_literal: true
 
 class Champs::DossierLinkChamp < Champ
-  validate :value_integerable, if: -> { value.present? }, on: :prefill
   validates_with DossierLinkValidator, if: -> { should_validate_in_current_context? && value.present? }
-
-  private
-
-  def value_integerable
-    Integer(value)
-  rescue ArgumentError
-    errors.add(:value, :not_integerable)
-  end
 end

app/models/champs/pays_champ.rb

@@ -6,13 +6,6 @@ class Champs::PaysChamp < Champs::TextChamp
     validates :value, inclusion: APIGeoService.countries.pluck(:name), allow_nil: true, allow_blank: false
   end
 
-  # def value=(code) can reset champs to nil if value is empty, in case of prefill
-  #   we do not want to try to save the champ with an nil value
-  with_options if: -> { validation_context == :prefill } do
-    validates :external_id, inclusion: APIGeoService.countries.pluck(:code), allow_nil: false, allow_blank: false
-    validates :value, inclusion: APIGeoService.countries.pluck(:name), allow_nil: false, allow_blank: false
-  end
-
   def selected
     code || value
   end

app/models/concerns/champ_validate_concern.rb

@@ -13,8 +13,6 @@ def should_validate_in_current_context?
     case validation_context
     when :champ_value
       visible?
-    when :prefill
-      true
     else
       false
     end

app/models/prefill_champs.rb

@@ -31,22 +31,6 @@ def build_prefill_values
   end
 
   class PrefillValue
-    NEED_VALIDATION_TYPES_DE_CHAMPS = [
-      TypeDeChamp.type_champs.fetch(:decimal_number),
-      TypeDeChamp.type_champs.fetch(:integer_number),
-      TypeDeChamp.type_champs.fetch(:date),
-      TypeDeChamp.type_champs.fetch(:datetime),
-      TypeDeChamp.type_champs.fetch(:civilite),
-      TypeDeChamp.type_champs.fetch(:yes_no),
-      TypeDeChamp.type_champs.fetch(:checkbox),
-      TypeDeChamp.type_champs.fetch(:pays),
-      TypeDeChamp.type_champs.fetch(:regions),
-      TypeDeChamp.type_champs.fetch(:departements),
-      TypeDeChamp.type_champs.fetch(:multiple_drop_down_list),
-      TypeDeChamp.type_champs.fetch(:epci),
-      TypeDeChamp.type_champs.fetch(:dossier_link),
-    ]
-
     attr_reader :champ, :value, :dossier
 
     def initialize(champ:, value:, dossier:)
@@ -56,7 +40,7 @@ def initialize(champ:, value:, dossier:)
     end
 
     def prefillable?
-      champ.prefillable? && champ_attributes.present? && valid?
+      champ.prefillable? && champ_attributes.present?
     end
 
     # An array of [champ, attributes] pairs; a repetition champ expands to
@@ -70,14 +54,5 @@ def champ_attributes
         .build(champ.type_de_champ, dossier.revision)
         .to_assignable_attributes(champ, value)
     end
-
-    private
-
-    def valid?
-      return true unless NEED_VALIDATION_TYPES_DE_CHAMPS.include?(champ.type_champ)
-
-      champ.assign_attributes(champ_attributes)
-      champ.valid?(:prefill)
-    end
   end
 end

config/locales/en.yml

@@ -855,10 +855,6 @@ en:
               not_in_departement_epci_codes: "must be a valid EPCI code of the matching department"
             value:
               not_in_departement_epci_names: "must be a valid EPCI name of the matching department"
-        "champs/dossier_link_champ":
-          attributes:
-            value:
-              not_integerable: "must be an integer"
         "champs/repetition_champ":
           attributes:
             value:

config/locales/fr.yml

@@ -866,10 +866,6 @@ fr:
               not_in_departement_epci_codes: "doit être un code d’EPCI du département correspondant"
             value:
               not_in_departement_epci_names: "doit être un nom d’EPCI du département correspondant"
-        "champs/dossier_link_champ":
-          attributes:
-            value:
-              not_integerable: "doit être un entier"
         "champs/repetition_champ":
           attributes:
             value:

spec/models/champs/date_champ_spec.rb

@@ -6,53 +6,37 @@
   let(:dossier) { create(:dossier, procedure:) }
   let(:date_champ) { dossier.champ_data.first }
 
-  describe '#convert_to_iso8601_date' do
+  describe 'value normalization' do
     it 'preserves nil' do
-      champ = champ_with_value(nil)
-      champ.validate
-      expect(champ.value).to be_nil
+      expect(champ_with_value(nil).value).to be_nil
     end
 
     it 'converts to nil if empty string' do
-      champ = champ_with_value("")
-      champ.validate
-      expect(champ.value).to be_nil
+      expect(champ_with_value("").value).to be_nil
     end
 
     it 'converts unambiguous US format to ISO' do
-      champ = champ_with_value("12-21-2023")
-      champ.validate
-      expect(champ.value).to eq("2023-12-21")
+      expect(champ_with_value("12-21-2023").value).to eq("2023-12-21")
     end
 
     it 'converts to nil if not a valid date' do
-      champ = champ_with_value("13/13/2023")
-      champ.validate
-      expect(champ.value).to be_nil
+      expect(champ_with_value("13/13/2023").value).to be_nil
     end
 
     it 'converts to nil if not date' do
-      champ = champ_with_value("value")
-      champ.validate
-      expect(champ.value).to be_nil
+      expect(champ_with_value("value").value).to be_nil
     end
 
     it "converts %d/%m/%Y format to ISO" do
-      champ = champ_with_value("31/12/2017")
-      champ.validate
-      expect(champ.value).to eq("2017-12-31")
+      expect(champ_with_value("31/12/2017").value).to eq("2017-12-31")
     end
 
     it 'preserves if ISO8601' do
-      champ = champ_with_value("2023-12-21")
-      champ.validate
-      expect(champ.value).to eq("2023-12-21")
+      expect(champ_with_value("2023-12-21").value).to eq("2023-12-21")
     end
 
     it 'converts to nil if false iso' do
-      champ = champ_with_value("2023-27-02")
-      champ.validate
-      expect(champ.value).to eq(nil)
+      expect(champ_with_value("2023-27-02").value).to eq(nil)
     end
   end
 
@@ -62,8 +46,8 @@
       expect(date_champ.to_s).to eq("20 juin 2020")
     end
 
-    it "does not fail when value is not iso" do
-      champ_with_value("2023-30-01")
+    it "does not fail when a legacy value stored in database is not iso" do
+      allow(date_champ).to receive(:value).and_return("2023-30-01")
       expect(date_champ.to_s).to eq("2023-30-01")
     end
   end

spec/models/champs/dossier_link_champ_spec.rb

@@ -8,43 +8,6 @@
   let(:value) { nil }
   let(:mandatory) { false }
 
-  describe 'prefilling validations' do
-    let(:linked_dossier) { create(:dossier, :en_construction) }
-    describe 'value' do
-      subject { champ.valid?(:prefill) }
-
-      context 'when nil' do
-        let(:value) { nil }
-
-        it { expect(subject).to eq(true) }
-      end
-
-      context 'when empty' do
-        let(:value) { '' }
-
-        it { expect(subject).to eq(true) }
-      end
-
-      context 'when an integer' do
-        let(:value) { linked_dossier.id }
-
-        it { expect(subject).to eq(true) }
-      end
-
-      context 'when a string representing an integer' do
-        let(:value) { linked_dossier.id.to_s }
-
-        it { expect(subject).to eq(true) }
-      end
-
-      context 'when it can be casted as integer' do
-        let(:value) { 'totoro' }
-
-        it { expect(subject).to eq(false) }
-      end
-    end
-  end
-
   describe 'validation' do
     subject { champ.validate(:champ_value) }
 

spec/models/concerns/dossier_prefillable_concern_spec.rb

@@ -140,6 +140,28 @@
       end
     end
 
+    context 'when a prefill value was rejected by the PrefillTypeDeChamp screening' do
+      # Regression: rejected prefill values used to be assigned to the champ while
+      # screening with champ.valid?(:prefill), and could leak to the database
+      # through the dossier champ_data autosave when a valid champ triggered a save.
+      let(:types_de_champ_public) { [{ type: :text }, { type: :date }] }
+      let(:text_type_de_champ) { procedure.published_revision.types_de_champ_public.first }
+      let(:date_type_de_champ) { procedure.published_revision.types_de_champ_public.second }
+      let(:params) do
+        {
+          "champ_#{text_type_de_champ.to_typed_id_for_query}" => "any value",
+          "champ_#{date_type_de_champ.to_typed_id_for_query}" => "not a date",
+        }
+      end
+      let(:values) { PrefillChamps.new(dossier, params).to_a }
+
+      it 'prefills the valid champ and does not persist the rejected value' do
+        fill
+        expect(find_champ_by_stable_id(dossier, text_type_de_champ.stable_id).value).to eq("any value")
+        expect(find_champ_by_stable_id(dossier, date_type_de_champ.stable_id)&.value).to be_nil
+      end
+    end
+
     context 'when dossier contains champs with external_id' do
       let(:types_de_champ_public) { [{ type: :siret }] }
       let(:values) { [[champ_1, { external_id: value_1 }]] }