extract computation to controller

app/controllers/administrateurs/procedures_controller.rb

@@ -334,14 +334,29 @@ module Administrateurs
 
     def all
       @filter = ProceduresFilter.new(current_administrateur, params)
+      @procedures = paginate(filter_procedures(@filter), published_at: :desc)
     end
 
     def administrateurs
       @filter = ProceduresFilter.new(current_administrateur, params)
+      @admins = Administrateur.includes(:user, :procedures).where(id: AdministrateursProcedure.where(procedure: filter_procedures(@filter)).select(:administrateur_id))
+      @admins = paginate(@admins, 'users.email')
     end
 
     private
 
+    def filter_procedures(filter)
+      procedures_result = Procedure.joins(:procedures_zones).publiees_ou_closes
+      procedures_result = procedures_result.where(procedures_zones: { zone_id: filter.zone_ids }) if filter.zone_ids.present?
+      procedures_result = procedures_result.where(aasm_state: filter.statuses) if filter.statuses.present?
+      procedures_result = procedures_result.where('published_at >= ?', filter.from_publication_date) if filter.from_publication_date.present?
+      procedures_result
+    end
+
+    def paginate(result, ordered_by)
+      result.page(params[:page]).per(ITEMS_PER_PAGE).order(ordered_by)
+    end
+
     def draft_valid?
       if procedure_without_control.draft_revision.invalid?
         flash.alert = t('preview_unavailable', scope: 'administrateurs.procedures')

app/models/procedures_filter.rb

@@ -52,29 +52,4 @@ class ProceduresFilter
       params.to_h.merge(filter => new_filter)
     end
   end
-
-  def procedures_result
-    return @procedures_result if @procedures_result
-    @procedures_result = paginate(filter_procedures, published_at: :desc)
-  end
-
-  def admins_result
-    return @admins_result if @admins_result
-    @admins_result = Administrateur.includes(:user).where(id: AdministrateursProcedure.where(procedure: filter_procedures).select(:administrateur_id))
-    @admins_result = paginate(@admins_result, 'users.email')
-  end
-
-  private
-
-  def filter_procedures
-    procedures_result = Procedure.joins(:procedures_zones).publiees_ou_closes
-    procedures_result = procedures_result.where(procedures_zones: { zone_id: zone_ids }) if zone_ids.present?
-    procedures_result = procedures_result.where(aasm_state: statuses) if statuses.present?
-    procedures_result = procedures_result.where('published_at >= ?', from_publication_date) if from_publication_date.present?
-    procedures_result
-  end
-
-  def paginate(result, ordered_by)
-    result.page(params[:page]).per(ITEMS_PER_PAGE).order(ordered_by)
-  end
 end

app/views/administrateurs/procedures/administrateurs.html.haml

@@ -5,7 +5,7 @@
   .fr-table.fr-table--bordered
     %table#all-admins
       %caption
-        = "#{@filter.admins_result.total_count} administrateurs"
+        = "#{@admins.total_count} administrateurs"
         %span.hidden.fr-icon-ball-pen-fill{ 'aria-hidden': 'true', 'data-autosubmit-target': 'spinner' }
       - if @filter.selected_zones.present?
         .selected-zones.fr-mb-2w
@@ -18,14 +18,14 @@
       - if @filter.from_publication_date.present?
         .selected-from-publication-date.fr-mb-2w
           = link_to "Depuis le #{l(@filter.from_publication_date)}", all_admin_procedures_path(@filter.without(:from_publication_date)), class: 'fr-tag fr-tag--dismiss fr-mb-1w'
-      = paginate @filter.admins_result, views_prefix: 'administrateurs'
+      = paginate @admins, views_prefix: 'administrateurs'
       %thead
         %tr
           %th{ scope: 'col' }
           %th{ scope: 'col' } Administrateurs
           %th{ scope: 'col' } Nb démarches
           %th{ scope: 'col' } Inscrit le
-      - @filter.admins_result.each do |admin|
+      - @admins.each do |admin|
         %tbody{ 'data-controller': 'expand' }
           %tr.procedure{ 'data-action': 'click->expand#toggle' }
             %td
@@ -40,4 +40,4 @@
                   %ul
                   - admin.procedures.each do |procedure|
                     %li= procedure.libelle
-    .fr-mt-2w= paginate @filter.admins_result, views_prefix: 'administrateurs'
+    .fr-mt-2w= paginate @admins, views_prefix: 'administrateurs'

app/views/administrateurs/procedures/all.html.haml

@@ -5,7 +5,7 @@
   .fr-table.fr-table--bordered
     %table#all-demarches
       %caption
-        = "#{@filter.procedures_result.total_count} démarches"
+        = "#{@procedures.total_count} démarches"
         %span.hidden.fr-icon-ball-pen-fill{ 'aria-hidden': 'true', 'data-autosubmit-target': 'spinner' }
       - if @filter.selected_zones.present?
         .selected-zones.fr-mb-2w
@@ -18,7 +18,7 @@
       - if @filter.from_publication_date.present?
         .selected-from-publication-date.fr-mb-2w
           = link_to "Depuis #{l(@filter.from_publication_date)}", all_admin_procedures_path(@filter.without(:from_publication_date)), class: 'fr-tag fr-tag--dismiss fr-mb-1w'
-      = paginate @filter.procedures_result, views_prefix: 'administrateurs'
+      = paginate @procedures, views_prefix: 'administrateurs'
       %thead
         %tr
           %th{ scope: 'col' }
@@ -27,7 +27,7 @@
           %th{ scope: 'col' } Administrateurs
           %th{ scope: 'col' } Statut
           %th{ scope: 'col' } Date
-      - @filter.procedures_result.each do |procedure|
+      - @procedures.each do |procedure|
         %tbody{ 'data-controller': 'expand' }
           %tr.procedure{ 'data-action': 'click->expand#toggle' }
             %td
@@ -47,4 +47,4 @@
                   .fr-col-6
                     - procedure.administrateurs.uniq.each do |admin|
                       = admin.email
-    .fr-mt-2w= paginate @filter.procedures_result, views_prefix: 'administrateurs'
+    .fr-mt-2w= paginate @procedures, views_prefix: 'administrateurs'

spec/controllers/administrateurs/procedures_controller_spec.rb

@@ -88,16 +88,84 @@ describe Administrateurs::ProceduresController, type: :controller do
   end
 
   describe 'GET #all' do
+    let!(:draft_procedure)     { create(:procedure) }
+    let!(:published_procedure) { create(:procedure_with_dossiers, :published, dossiers_count: 2) }
+    let!(:closed_procedure)    { create(:procedure, :closed) }
     subject { get :all }
 
     it { expect(subject.status).to eq(200) }
 
-    it 'assigns ProceduresFilter' do
+    it 'display published or closed procedures' do
-      filter = double('filter')
-      expect(ProceduresFilter).to receive(:new).and_return(filter)
       subject
+      expect(assigns(:procedures)).to include(published_procedure)
+      expect(assigns(:procedures)).to include(closed_procedure)
+    end
 
-      expect(assigns(:filter)).to be_present
+    it 'doesn’t display draft procedures' do
+      subject
+      expect(assigns(:procedures)).not_to include(draft_procedure)
+    end
+
+    context "for specific zones" do
+      let(:zone1) { create(:zone) }
+      let(:zone2) { create(:zone) }
+      let!(:procedure1) { create(:procedure, :published, zones: [zone1]) }
+      let!(:procedure2) { create(:procedure, :published, zones: [zone1, zone2]) }
+
+      subject { get :all, params: { zone_ids: [zone2.id] } }
+
+      it 'display only procedures for specified zones' do
+        subject
+        expect(assigns(:procedures)).to include(procedure2)
+        expect(assigns(:procedures)).not_to include(procedure1)
+      end
+    end
+
+    context 'for specific status' do
+      let!(:procedure1) { create(:procedure, :published) }
+      let!(:procedure2) { create(:procedure, :closed) }
+
+      it 'display only published procedures' do
+        get :all, params: { statuses: ['publiee'] }
+        expect(assigns(:procedures)).to include(procedure1)
+        expect(assigns(:procedures)).not_to include(procedure2)
+      end
+
+      it 'display only closed procedures' do
+        get :all, params: { statuses: ['close'] }
+        expect(assigns(:procedures)).to include(procedure2)
+        expect(assigns(:procedures)).not_to include(procedure1)
+      end
+    end
+
+    context 'after specific date' do
+      let(:after) { Date.new(2022, 06, 30) }
+      let!(:procedure1) { create(:procedure, :published, published_at: after + 1.day) }
+      let!(:procedure2) { create(:procedure, :published, published_at: after + 2.days) }
+      let!(:procedure3) { create(:procedure, :published, published_at: after - 1.day) }
+
+      it 'display only procedures published after specific date' do
+        get :all, params: { from_publication_date: after }
+        expect(assigns(:procedures)).to include(procedure1)
+        expect(assigns(:procedures)).to include(procedure2)
+        expect(assigns(:procedures)).not_to include(procedure3)
+      end
+    end
+  end
+
+  describe 'GET #administrateurs' do
+    let!(:draft_procedure)     { create(:procedure, administrateur: admin3) }
+    let!(:published_procedure) { create(:procedure_with_dossiers, :published, dossiers_count: 2, administrateur: admin1) }
+    let!(:closed_procedure)    { create(:procedure, :closed, administrateur: admin2) }
+    let(:admin1) { create(:administrateur) }
+    let(:admin2) { create(:administrateur) }
+    let(:admin3) { create(:administrateur) }
+
+    it 'displays admins of the procedures' do
+      get :administrateurs
+      expect(assigns(:admins)).to include(admin1)
+      expect(assigns(:admins)).to include(admin2)
+      expect(assigns(:admins)).not_to include(admin3)
     end
   end
 

spec/models/procedures_filter_spec.rb

@@ -1,90 +0,0 @@
-describe ProceduresFilter do
-  let(:admin) { create(:administrateur) }
-  let(:params) { ActionController::Parameters.new(filters) }
-  let(:subject) { ProceduresFilter.new(admin, params) }
-
-  context 'without filter' do
-    let(:filters) { {} }
-    let!(:draft_procedure)     { create(:procedure, administrateur: admin3) }
-    let!(:published_procedure) { create(:procedure_with_dossiers, :published, dossiers_count: 2, administrateur: admin1) }
-    let!(:closed_procedure)    { create(:procedure, :closed, administrateur: admin2) }
-    let(:admin1) { create(:administrateur) }
-    let(:admin2) { create(:administrateur) }
-    let(:admin3) { create(:administrateur) }
-
-    it 'returns only published and closed procedures' do
-      expect(subject.procedures_result).to include(published_procedure)
-      expect(subject.procedures_result).to include(closed_procedure)
-      expect(subject.procedures_result).not_to include(draft_procedure)
-    end
-
-    context 'with view_admins param' do
-      it 'returns admins of the procedures' do
-        expect(subject.admins_result).to include(admin1)
-        expect(subject.admins_result).to include(admin2)
-        expect(subject.admins_result).not_to include(admin3)
-      end
-    end
-  end
-
-  context 'with zone filter' do
-    let(:zone1) { create(:zone) }
-    let(:zone2) { create(:zone) }
-    let!(:procedure1) { create(:procedure, :published, zones: [zone1]) }
-    let!(:procedure2) { create(:procedure, :published, zones: [zone1, zone2]) }
-    let(:filters) { { zone_ids: [zone2.id] } }
-
-    it 'returns only procedures for specified zones' do
-      expect(subject.procedures_result).to include(procedure2)
-      expect(subject.procedures_result).not_to include(procedure1)
-    end
-  end
-
-  context 'with published status filter' do
-    let!(:procedure1) { create(:procedure, :published) }
-    let!(:procedure2) { create(:procedure, :closed) }
-    let(:filters) { { statuses: ['publiee'] } }
-
-    it 'returns only published procedures' do
-      expect(subject.procedures_result).to include(procedure1)
-      expect(subject.procedures_result).not_to include(procedure2)
-    end
-  end
-
-  context 'with closed status filter' do
-    let!(:procedure1) { create(:procedure, :published) }
-    let!(:procedure2) { create(:procedure, :closed) }
-    let(:filters) { { statuses: ['close'] } }
-
-    it 'returns only closed procedures' do
-      expect(subject.procedures_result).to include(procedure2)
-      expect(subject.procedures_result).not_to include(procedure1)
-    end
-  end
-
-  context 'with specific date filter' do
-    let(:after) { '2022-06-30' }
-    let(:after_date) { Date.parse(after) }
-    let!(:procedure1) { create(:procedure, :published, published_at: after_date + 1.day) }
-    let!(:procedure2) { create(:procedure, :published, published_at: after_date + 2.days) }
-    let!(:procedure3) { create(:procedure, :published, published_at: after_date - 1.day) }
-
-    let(:filters) { { from_publication_date: after } }
-
-    it 'returns only procedures published after specific date' do
-      expect(subject.procedures_result).to include(procedure1)
-      expect(subject.procedures_result).to include(procedure2)
-      expect(subject.procedures_result).not_to include(procedure3)
-    end
-  end
-
-  context 'with bad date input' do
-    let(:after) { 'oops' }
-    let!(:procedure1) { create(:procedure, :published) }
-    let(:filters) { { from_publication_date: after } }
-
-    it 'ignores date filter' do
-      expect(subject.procedures_result).to include(procedure1)
-    end
-  end
-end