406 lines
12 KiB
Ruby
406 lines
12 KiB
Ruby
require 'spec_helper'
|
|
|
|
describe Backoffice::DossiersController, type: :controller do
|
|
before do
|
|
@request.env['HTTP_REFERER'] = TPS::Application::URL
|
|
end
|
|
let(:procedure) { create :procedure, :published }
|
|
let(:procedure2) { create :procedure, :published }
|
|
|
|
let(:dossier) { create(:dossier, :with_entreprise, procedure: procedure, state: :en_construction) }
|
|
let(:dossier2) { create(:dossier, :with_entreprise, procedure: procedure2, state: :en_construction) }
|
|
let(:dossier_archived) { create(:dossier, :with_entreprise, archived: true) }
|
|
|
|
let(:dossier_id) { dossier.id }
|
|
let(:dossier2_id) { dossier2.id }
|
|
let(:bad_dossier_id) { Dossier.count + 10 }
|
|
|
|
let(:gestionnaire) { create(:gestionnaire, administrateurs: [create(:administrateur)]) }
|
|
let!(:gestionnaire2) { create(:gestionnaire, administrateurs: [create(:administrateur)]) }
|
|
|
|
before do
|
|
create :assign_to, procedure: procedure, gestionnaire: gestionnaire
|
|
create :assign_to, procedure: procedure2, gestionnaire: gestionnaire2
|
|
|
|
procedure.dossiers << dossier
|
|
procedure2.dossiers << dossier2
|
|
end
|
|
|
|
describe 'GET #index' do
|
|
subject { get :index }
|
|
|
|
before do
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
context 'when gestionnaire is assign to a procedure' do
|
|
it { is_expected.to redirect_to backoffice_dossiers_procedure_path(id: procedure.id) }
|
|
|
|
context 'when gestionnaire is assign to many proceudure' do
|
|
before do
|
|
create :assign_to, procedure: create(:procedure, :published), gestionnaire: gestionnaire
|
|
create :assign_to, procedure: create(:procedure, :published), gestionnaire: gestionnaire
|
|
end
|
|
|
|
it { expect(gestionnaire.procedures.count).to eq 3 }
|
|
|
|
context 'when gestionnaire procedure_filter is nil' do
|
|
it { expect(gestionnaire.procedure_filter).to be_nil }
|
|
it { is_expected.to redirect_to backoffice_dossiers_procedure_path(id: gestionnaire.procedures.order('libelle ASC').first.id) }
|
|
end
|
|
|
|
context 'when gestionnaire procedure_filter is not nil' do
|
|
let(:procedure_filter_id) { gestionnaire.procedures.order('libelle ASC').last.id }
|
|
|
|
before do
|
|
gestionnaire.update_column :procedure_filter, procedure_filter_id
|
|
end
|
|
|
|
context 'when gestionnaire is assign_to the procedure filter id' do
|
|
it { is_expected.to redirect_to backoffice_dossiers_procedure_path(id: procedure_filter_id) }
|
|
end
|
|
|
|
context 'when gestionnaire not any more assign_to the procedure filter id' do
|
|
before do
|
|
AssignTo.where(procedure: procedure_filter_id, gestionnaire: gestionnaire).delete_all
|
|
end
|
|
|
|
it { expect(gestionnaire.procedure_filter).to be_nil }
|
|
it { expect(AssignTo.where(procedure: procedure_filter_id, gestionnaire: gestionnaire).count).to eq 0 }
|
|
|
|
it { is_expected.to redirect_to backoffice_dossiers_procedure_path(id: gestionnaire.procedures.order('libelle ASC').first.id) }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when gestionnaire is not assign to a procedure' do
|
|
before do
|
|
AssignTo.where(procedure: procedure, gestionnaire: gestionnaire).delete_all
|
|
end
|
|
|
|
it { is_expected.to redirect_to root_path }
|
|
end
|
|
end
|
|
|
|
describe 'GET #show' do
|
|
subject { get :show, params: {id: dossier_id} }
|
|
|
|
context 'gestionnaire is connected' do
|
|
before do
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
it 'returns http success' do
|
|
expect(subject).to have_http_status(200)
|
|
end
|
|
|
|
describe 'all notifications unread are changed' do
|
|
it do
|
|
expect(Notification).to receive(:where).with(dossier_id: dossier_id.to_s).and_return(Notification::ActiveRecord_Relation)
|
|
expect(Notification::ActiveRecord_Relation).to receive(:update_all).with(already_read: true).and_return(true)
|
|
|
|
subject
|
|
end
|
|
end
|
|
|
|
context 'when dossier id does not exist' do
|
|
let(:dossier_id) { bad_dossier_id }
|
|
|
|
it { expect(subject).to redirect_to('/backoffice') }
|
|
end
|
|
|
|
describe 'he can invite somebody for avis' do
|
|
render_views
|
|
|
|
it { expect(subject.body).to include("Invitez une personne externe à consulter le dossier et à vous donner un avis sur celui ci.") }
|
|
end
|
|
|
|
context 'and is invited on a dossier' do
|
|
let(:dossier_invited){ create(:dossier, procedure: create(:procedure)) }
|
|
let!(:avis){ create(:avis, dossier: dossier_invited, gestionnaire: gestionnaire) }
|
|
|
|
subject { get :show, params: { id: dossier_invited.id } }
|
|
|
|
render_views
|
|
|
|
it { expect(subject.status).to eq(200) }
|
|
it { expect(subject.body).to include("Votre avis est sollicité sur le dossier") }
|
|
it { expect(subject.body).to_not include("Invitez une personne externe à consulter le dossier et à vous donner un avis sur celui ci.") }
|
|
|
|
describe 'the notifications are not marked as read' do
|
|
it do
|
|
expect(Notification).not_to receive(:where)
|
|
subject
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'gestionnaire does not connected but dossier id is correct' do
|
|
it { is_expected.to redirect_to('/users/sign_in') }
|
|
end
|
|
end
|
|
|
|
describe 'GET #a_traiter' do
|
|
context 'when gestionnaire is connected' do
|
|
before do
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
it 'returns http success' do
|
|
get :index, params: {liste: :a_traiter}
|
|
expect(response).to have_http_status(302)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'GET #termine' do
|
|
context 'when gestionnaire is connected' do
|
|
before do
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
it 'returns http success' do
|
|
get :index, params: {liste: :termine}
|
|
expect(response).to have_http_status(302)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'GET #list_fake' do
|
|
context 'when gestionnaire is connected' do
|
|
before do
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
it 'returns http success' do
|
|
get :index, params: {liste: :list_fake}
|
|
expect(response).to redirect_to(backoffice_dossiers_procedure_path(id: gestionnaire.procedures.first.id))
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'POST #search' do
|
|
describe 'by id' do
|
|
context 'when I am logged as a gestionnaire' do
|
|
before do
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
context 'when I own the dossier' do
|
|
before :each do
|
|
post :search, params: { q: dossier_id }
|
|
end
|
|
|
|
it 'returns http success' do
|
|
expect(response).to have_http_status(200)
|
|
end
|
|
|
|
it 'returns the expected dossier' do
|
|
expect(assigns(:dossiers).count).to eq(1)
|
|
expect(assigns(:dossiers).first.id).to eq(dossier_id)
|
|
end
|
|
end
|
|
|
|
context 'when I do not own the dossier' do
|
|
before :each do
|
|
post :search, params: { q: dossier2_id }
|
|
end
|
|
|
|
it 'returns http success' do
|
|
expect(response).to have_http_status(200)
|
|
end
|
|
|
|
it 'does not return the dossier' do
|
|
expect(assigns(:dossiers).pluck(:id)).not_to include(dossier2_id)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'POST #receive' do
|
|
before do
|
|
dossier.en_construction!
|
|
sign_in gestionnaire
|
|
post :receive, params: { dossier_id: dossier_id }
|
|
dossier.reload
|
|
end
|
|
|
|
it { expect(dossier.state).to eq('en_instruction') }
|
|
it { is_expected.to redirect_to backoffice_dossier_path(dossier) }
|
|
it { expect(gestionnaire.follow?(dossier)).to be true }
|
|
end
|
|
|
|
describe 'POST #process_dossier' do
|
|
context "with refuse" do
|
|
before do
|
|
dossier.en_instruction!
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
subject { post :process_dossier, params: { process_action: "refuse", dossier_id: dossier_id} }
|
|
|
|
it 'change state to refuse' do
|
|
subject
|
|
|
|
dossier.reload
|
|
expect(dossier.state).to eq('refuse')
|
|
end
|
|
|
|
it 'Notification email is sent' do
|
|
expect(NotificationMailer).to receive(:send_notification)
|
|
.with(dossier, kind_of(Mails::RefusedMail), nil).and_return(NotificationMailer)
|
|
expect(NotificationMailer).to receive(:deliver_now!)
|
|
|
|
subject
|
|
end
|
|
|
|
it { is_expected.to redirect_to backoffice_dossier_path(id: dossier.id) }
|
|
end
|
|
|
|
context "with sans_suite" do
|
|
before do
|
|
dossier.en_instruction!
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
subject { post :process_dossier, params: { process_action: "without_continuation", dossier_id: dossier_id} }
|
|
|
|
it 'change state to sans_suite' do
|
|
subject
|
|
|
|
dossier.reload
|
|
expect(dossier.state).to eq('sans_suite')
|
|
end
|
|
|
|
it 'Notification email is sent' do
|
|
expect(NotificationMailer).to receive(:send_notification)
|
|
.with(dossier, kind_of(Mails::WithoutContinuationMail), nil).and_return(NotificationMailer)
|
|
expect(NotificationMailer).to receive(:deliver_now!)
|
|
|
|
subject
|
|
end
|
|
|
|
it { is_expected.to redirect_to backoffice_dossier_path(id: dossier.id) }
|
|
end
|
|
|
|
context "with close" do
|
|
let(:expected_attestation) { nil }
|
|
|
|
before do
|
|
dossier.en_instruction!
|
|
sign_in gestionnaire
|
|
|
|
expect(NotificationMailer).to receive(:send_notification)
|
|
.with(dossier, kind_of(Mails::ClosedMail), expected_attestation)
|
|
.and_return(NotificationMailer)
|
|
|
|
expect(NotificationMailer).to receive(:deliver_now!)
|
|
end
|
|
|
|
subject { post :process_dossier, params: { process_action: "close", dossier_id: dossier_id} }
|
|
|
|
it 'change state to accepte' do
|
|
subject
|
|
|
|
dossier.reload
|
|
expect(dossier.state).to eq('accepte')
|
|
end
|
|
|
|
context 'when the dossier does not have any attestation' do
|
|
it 'Notification email is sent' do
|
|
subject
|
|
end
|
|
end
|
|
|
|
context 'when the dossier has an attestation' do
|
|
before do
|
|
attestation = Attestation.new
|
|
allow(attestation).to receive(:pdf).and_return(double(read: 'pdf', size: 2.megabytes))
|
|
allow(attestation).to receive(:emailable?).and_return(emailable)
|
|
|
|
expect_any_instance_of(Dossier).to receive(:reload)
|
|
allow_any_instance_of(Dossier).to receive(:build_attestation).and_return(attestation)
|
|
end
|
|
|
|
context 'emailable' do
|
|
let(:emailable) { true }
|
|
let(:expected_attestation) { 'pdf' }
|
|
|
|
it 'Notification email is sent with the attestation' do
|
|
subject
|
|
|
|
is_expected.to redirect_to backoffice_dossier_path(id: dossier.id)
|
|
end
|
|
end
|
|
|
|
context 'when the dossier has an attestation not emailable' do
|
|
let(:emailable) { false }
|
|
let(:expected_attestation) { nil }
|
|
|
|
it 'Notification email is sent without the attestation' do
|
|
expect(controller).to receive(:capture_message)
|
|
|
|
subject
|
|
|
|
is_expected.to redirect_to backoffice_dossier_path(id: dossier.id)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when the attestation template uses the motivation field' do
|
|
let(:emailable) { false }
|
|
let(:template) { create(:attestation_template) }
|
|
let(:procedure) { create(:procedure, :published, attestation_template: template, gestionnaires: [gestionnaire]) }
|
|
|
|
subject { post :process_dossier, params: { process_action: "close", dossier_id: dossier_id, dossier: { motivation: "Yallah" }}}
|
|
|
|
before do
|
|
expect_any_instance_of(AttestationTemplate)
|
|
.to receive(:attestation_for)
|
|
.with(have_attributes(motivation: "Yallah"))
|
|
end
|
|
|
|
it { subject }
|
|
end
|
|
end
|
|
end
|
|
|
|
describe 'POST #reopen' do
|
|
before do
|
|
dossier.en_instruction!
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
subject { post :reopen, params: {dossier_id: dossier_id} }
|
|
|
|
it 'change state to en_construction' do
|
|
subject
|
|
|
|
dossier.reload
|
|
expect(dossier.state).to eq('en_construction')
|
|
end
|
|
|
|
it { is_expected.to redirect_to backoffice_dossier_path(id: dossier_id) }
|
|
end
|
|
|
|
describe 'POST #archive' do
|
|
before do
|
|
dossier.update(archived: false)
|
|
sign_in gestionnaire
|
|
end
|
|
|
|
subject { post :archive, params: {id: dossier_id} }
|
|
|
|
it 'change state to archived' do
|
|
subject
|
|
|
|
dossier.reload
|
|
expect(dossier.archived).to eq(true)
|
|
end
|
|
|
|
it { is_expected.to redirect_to backoffice_dossiers_path }
|
|
end
|
|
end
|