DGNum/demarches-normaliennes
15
1
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity

Merge pull request #10483 from colinux/fast-tests

Browse source 
Tech (tests): default administrateur fixtures
This commit is contained in:
Colin Darie 2024-07-01 21:35:11 +00:00 committed by GitHub
commit eee6e5e651
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
83 changed files with 490 additions and 378 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Gemfile
View file

@ -129,6 +129,7 @@ group :test do
gem 'shoulda-matchers', require: false
gem 'simplecov', require: false
gem 'simplecov-cobertura', require: false
gem "test-prof"
gem 'timecop'
gem 'vcr'
gem 'webmock'

2
Gemfile.lock
View file

@ -783,6 +783,7 @@ GEM
temple (0.8.2)
terminal-table (3.0.2)
unicode-display_width (>= 1.1.1, < 3)
test-prof (1.3.3)
thor (1.3.1)
thread_safe (0.3.6)
tilt (2.3.0)
@ -1019,6 +1020,7 @@ DEPENDENCIES
string-similarity
strong_migrations
sys-proctable
test-prof
timecop
turbo-rails
typhoeus

10
spec/components/dossiers/message_component_spec.rb
View file

@ -196,7 +196,7 @@ RSpec.describe Dossiers::MessageComponent, type: :component do
describe 'groupe_gestionnaire' do
let(:show_reply_button) { false }
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: create(:administrateur)) }
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: administrateurs(:default_admin)) }
let(:groupe_gestionnaire) { commentaire.groupe_gestionnaire }
let(:connected_user) { commentaire.sender }
subject { render_inline(component).to_html }
@ -222,7 +222,7 @@ RSpec.describe Dossiers::MessageComponent, type: :component do
context 'with an gestionnaire message' do
let(:gestionnaire) { create(:gestionnaire) }
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: create(:administrateur), gestionnaire: gestionnaire, body: 'Second message') }
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: administrateurs(:default_admin), gestionnaire: gestionnaire, body: 'Second message') }
it 'should display gestionnaire\'s email' do
is_expected.to have_text(gestionnaire.email)
@ -237,14 +237,14 @@ RSpec.describe Dossiers::MessageComponent, type: :component do
end
context 'when commentaire had been written by connected gestionnaire and discarded' do
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: create(:administrateur), gestionnaire: gestionnaire, body: 'Second message', discarded_at: 2.days.ago) }
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: administrateurs(:default_admin), gestionnaire: gestionnaire, body: 'Second message', discarded_at: 2.days.ago) }
it { is_expected.not_to have_selector("form[action=\"#{form_url}\"]") }
it { is_expected.to have_selector(".rich-text", text: component.t('.deleted_body')) }
end
context 'on a procedure where commentaire had been written another gestionnaire' do
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: create(:administrateur), gestionnaire: create(:gestionnaire), body: 'Second message') }
let(:commentaire) { create(:commentaire_groupe_gestionnaire, sender: administrateurs(:default_admin), gestionnaire: create(:gestionnaire), body: 'Second message') }
it { is_expected.not_to have_selector("form[action=\"#{form_url}\"]") }
end
@ -261,7 +261,7 @@ RSpec.describe Dossiers::MessageComponent, type: :component do
let(:present_date) { Time.zone.local(2018, 9, 2, 10, 5, 0) }
let(:creation_date) { present_date }
let(:commentaire) do
Timecop.freeze(creation_date) { create(:commentaire_groupe_gestionnaire, sender: create(:administrateur)) }
Timecop.freeze(creation_date) { create(:commentaire_groupe_gestionnaire, sender: administrateurs(:default_admin)) }
end
subject do

4
spec/controllers/administrateurs/activate_controller_spec.rb
View file

@ -1,6 +1,6 @@
describe Administrateurs::ActivateController, type: :controller do
describe '#new' do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:token) { admin.user.send(:set_reset_password_token) }
before { allow(controller).to receive(:trust_device) }
@ -19,7 +19,7 @@ describe Administrateurs::ActivateController, type: :controller do
end
describe '#create' do
let!(:administrateur) { create(:administrateur) }
let!(:administrateur) { administrateurs(:default_admin) }
let(:token) { administrateur.user.send(:set_reset_password_token) }
let(:password) { 'Another-password-ok!@#123?' }

4
spec/controllers/administrateurs/api_tokens_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::APITokensController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure, administrateur: admin) }
before { sign_in(admin.user) }
@ -84,7 +84,7 @@ describe Administrateurs::APITokensController, type: :controller do
end
context 'with procedure filtering on a procedure not owned by the admin' do
let(:another_procedure) { create(:procedure) }
let(:another_procedure) { create(:procedure, :new_administrateur) }
let(:params) { default_params.merge(target: 'custom', targets: [another_procedure.id]) }
it do

13
spec/controllers/administrateurs/archives_controller_spec.rb
View file

@ -1,7 +1,6 @@
describe Administrateurs::ArchivesController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create :procedure, groupe_instructeurs: [groupe_instructeur1, groupe_instructeur2] }
let(:administrateur_procedure) { create(:administrateurs_procedure, procedure: procedure, administrateur: admin, manager: manager) }
let(:groupe_instructeur1) { create(:groupe_instructeur) }
let(:groupe_instructeur2) { create(:groupe_instructeur) }
@ -15,7 +14,7 @@ describe Administrateurs::ArchivesController, type: :controller do
context 'when logged in as administrateur_procedure.manager=false' do
let(:manager) { false }
before do
administrateur_procedure
admin.administrateurs_procedures.where(procedure:).update_all(manager:)
sign_in(admin.user)
end
@ -30,7 +29,7 @@ describe Administrateurs::ArchivesController, type: :controller do
let(:manager) { true }
before do
administrateur_procedure
admin.administrateurs_procedures.where(procedure:).update_all(manager:)
sign_in(admin.user)
end
@ -49,13 +48,13 @@ describe Administrateurs::ArchivesController, type: :controller do
let(:manager) { false }
before do
administrateur_procedure
admin.administrateurs_procedures.where(procedure:).update_all(manager:)
sign_in(admin.user)
end
it { is_expected.to redirect_to(admin_procedure_archives_path(procedure)) }
it 'enqueue the creation job' do
expect { subject }.to have_enqueued_job(ArchiveCreationJob).with(procedure, an_instance_of(Archive), admin)
expect(subject).to redirect_to(admin_procedure_archives_path(procedure))
end
end
@ -63,7 +62,7 @@ describe Administrateurs::ArchivesController, type: :controller do
let(:manager) { true }
before do
administrateur_procedure
admin.administrateurs_procedures.where(procedure:).update_all(manager:)
sign_in(admin.user)
end

2
spec/controllers/administrateurs/attestation_template_v2s_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::AttestationTemplateV2sController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:attestation_template) { build(:attestation_template, :v2) }
let(:procedure) { create(:procedure, :published, administrateur: admin, attestation_template:, libelle: "Ma démarche") }
let(:logo) { fixture_file_upload('spec/fixtures/files/white.png', 'image/png') }

2
spec/controllers/administrateurs/attestation_templates_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::AttestationTemplatesController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:attestation_template) { build(:attestation_template) }
let(:procedure) { create(:procedure, administrateur: admin, attestation_template: attestation_template) }
let(:logo) { fixture_file_upload('spec/fixtures/files/white.png', 'image/png') }

2
spec/controllers/administrateurs/dossier_submitted_messages_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::DossierSubmittedMessagesController, type: :controller do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before { sign_in(administrateur.user) }

2
spec/controllers/administrateurs/experts_procedures_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::ExpertsProceduresController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create :procedure, administrateur: admin }
before do

13
spec/controllers/administrateurs/exports_controller_spec.rb
View file

@ -1,6 +1,6 @@
describe Administrateurs::ExportsController, type: :controller do
describe '#download' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before { sign_in(administrateur.user) }
subject do
@ -8,7 +8,7 @@ describe Administrateurs::ExportsController, type: :controller do
end
context 'when the procedure does not belongs to admin' do
let!(:procedure) { create(:procedure, administrateurs: [create(:administrateur)]) }
let!(:procedure) { create(:procedure, :new_administrateur) }
it 'blocks' do
is_expected.to have_http_status(:not_found)
end
@ -19,11 +19,10 @@ describe Administrateurs::ExportsController, type: :controller do
context 'when the export is does not exist' do
it 'displays an notice' do
is_expected.to redirect_to(admin_procedure_archives_url(procedure))
expect { subject }.to change(Export, :count).by(1)
expect(subject).to redirect_to(admin_procedure_archives_url(procedure))
expect(flash.notice).to be_present
end
it { expect { subject }.to change(Export, :count).by(1) }
end
context 'when the export is not ready' do
@ -66,7 +65,9 @@ describe Administrateurs::ExportsController, type: :controller do
context 'when admin is allowed present as manager' do
let!(:procedure) { create(:procedure) }
let!(:administrateur_procedure) { create(:administrateurs_procedure, procedure: procedure, administrateur: administrateur, manager: true) }
before do
procedure.administrateurs_procedures.update_all(manager: true)
end
context 'get #index.html' do
it { is_expected.to have_http_status(:forbidden) }

2
spec/controllers/administrateurs/groupe_gestionnaire_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::GroupeGestionnaireController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
describe "#show" do
subject { get :show }

277
spec/controllers/administrateurs/groupe_instructeurs_controller_spec.rb
View file

@ -2,7 +2,7 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
render_views
include Logic
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure, :routee, :published, :for_individual, administrateurs: [admin]) }
let!(:gi_1_1) { procedure.defaut_groupe_instructeur }
@ -52,9 +52,8 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
let!(:instructeur_not_assigned_2) { create :instructeur, email: 'instructeur_4@ministere-b.gouv.fr', administrateurs: [admin] }
subject! { get :show, params: { procedure_id: procedure.id, id: gi_1_1.id } }
it { expect(response.status).to eq(200) }
it 'sets the assigned and not assigned instructeurs' do
expect(response.status).to eq(200)
expect(assigns(:instructeurs)).to match_array([instructeur_assigned_1, instructeur_assigned_2])
expect(assigns(:available_instructeur_emails)).to match_array(['instructeur_3@ministere-a.gouv.fr', 'instructeur_4@ministere-b.gouv.fr'])
end
@ -104,17 +103,21 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
context 'with a valid name' do
let(:label) { "nouveau_groupe" }
it { expect(flash.notice).to be_present }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, procedure.groupe_instructeurs.last)) }
it { expect(procedure.groupe_instructeurs.count).to eq(3) }
it do
expect(flash.notice).to be_present
expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, procedure.groupe_instructeurs.last))
expect(procedure.groupe_instructeurs.count).to eq(3)
end
end
context 'with an invalid group name' do
let(:label) { gi_1_1.label }
it { expect(response).to render_template(:index) }
it { expect(procedure.groupe_instructeurs.count).to eq(2) }
it { expect(flash.alert).to be_present }
it do
expect(response).to render_template(:index)
expect(procedure.groupe_instructeurs.count).to eq(2)
expect(flash.alert).to be_present
end
end
end
@ -132,28 +135,35 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
delete_group gi_1_1
end
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq "Suppression impossible : le groupe « défaut » est le groupe par défaut." }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeurs_path(procedure)) }
it { expect(procedure.groupe_instructeurs.count).to eq(2) }
it 'verifies flash alerts and redirections' do
expect(flash.alert).to be_present
expect(flash.alert).to eq "Suppression impossible : le groupe « défaut » est le groupe par défaut."
expect(response).to redirect_to(admin_procedure_groupe_instructeurs_path(procedure))
expect(procedure.groupe_instructeurs.count).to eq(2)
end
end
context 'with many groups' do
context 'of a group that can be deleted' do
before { delete_group gi_1_2 }
it { expect(flash.notice).to eq "le groupe « deuxième groupe » a été supprimé et le routage a été désactivé." }
it { expect(procedure.groupe_instructeurs.count).to eq(1) }
it { expect(procedure.reload.routing_enabled?).to eq(false) }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeurs_path(procedure)) }
it 'deletes the group and updates routing' do
expect(flash.notice).to eq "le groupe « deuxième groupe » a été supprimé et le routage a été désactivé."
expect(procedure.groupe_instructeurs.count).to eq(1)
expect(procedure.reload.routing_enabled?).to eq(false)
expect(response).to redirect_to(admin_procedure_groupe_instructeurs_path(procedure))
end
end
context 'of a group with dossiers, that cannot be deleted' do
let!(:dossier12) { create(:dossier, procedure: procedure, state: Dossier.states.fetch(:en_construction), groupe_instructeur: gi_1_2) }
before { delete_group gi_1_2 }
it { expect(flash.alert).to be_present }
it { expect(procedure.groupe_instructeurs.count).to eq(2) }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeurs_path(procedure)) }
it 'attempts to delete a group with active dossiers and fails' do
expect(flash.alert).to be_present
expect(procedure.groupe_instructeurs.count).to eq(2)
expect(response).to redirect_to(admin_procedure_groupe_instructeurs_path(procedure))
end
end
end
end
@ -173,10 +183,12 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
:target_group => group)
end
it { expect(response).to have_http_status(:ok) }
it { expect(response.body).to include(reaffecter_url(procedure.defaut_groupe_instructeur)) }
it { expect(response.body).not_to include(reaffecter_url(gi_1_2)) }
it { expect(response.body).to include(reaffecter_url(gi_1_3)) }
it 'checks response and body content for specific conditions' do
expect(response).to have_http_status(:ok)
expect(response.body).to include(reaffecter_url(procedure.defaut_groupe_instructeur))
expect(response.body).not_to include(reaffecter_url(gi_1_2))
expect(response.body).to include(reaffecter_url(gi_1_3))
end
end
describe '#reaffecter' do
@ -319,25 +331,29 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
describe '#add_instructeur_procedure_non_routee' do
# faire la meme chose sur une procedure non routee
let(:procedure_non_routee) { create :procedure }
let!(:groupe_instructeur) { create(:administrateurs_procedure, procedure: procedure_non_routee, administrateur: admin, manager: manager) }
let(:procedure_non_routee) { create(:procedure, administrateur: admin) }
let(:emails) { ['instructeur_3@ministere_a.gouv.fr', 'instructeur_4@ministere_b.gouv.fr'].to_json }
subject { post :add_instructeur, params: { emails: emails, procedure_id: procedure_non_routee.id, id: procedure_non_routee.defaut_groupe_instructeur.id } }
let(:manager) { false }
before {
procedure_non_routee.administrateurs_procedures.where(administrateur: admin).update_all(manager:)
}
subject { post :add_instructeur, params: { emails: emails, procedure_id: procedure_non_routee.id, id: procedure_non_routee.defaut_groupe_instructeur.id } }
context 'when all emails are valid' do
let(:emails) { ['test@b.gouv.fr', 'test2@b.gouv.fr'].to_json }
it { expect(response.status).to eq(200) }
it { expect(subject.request.flash[:alert]).to be_nil }
it { expect(subject.request.flash[:notice]).to be_present }
it { expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee) }
it do
expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee)
expect(subject.request.flash[:alert]).to be_nil
expect(subject.request.flash[:notice]).to be_present
end
end
context 'when there is at least one bad email' do
let(:emails) { ['badmail', 'instructeur2@gmail.com'].to_json }
it { expect(response.status).to eq(200) }
it { expect(subject.request.flash[:alert]).to be_present }
it { expect(subject.request.flash[:notice]).to be_present }
it { expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee) }
it do
expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee)
expect(subject.request.flash[:alert]).to be_present
expect(subject.request.flash[:notice]).to be_present
end
end
context 'when the admin wants to assign an instructor who is already assigned on this procedure' do
@ -379,11 +395,11 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
.and_return(double(deliver_later: true))
do_request
end
it { expect(gi_1_2.instructeurs.pluck(:email)).to include(*new_instructeur_emails) }
it { expect(flash.notice).to be_present }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_2)) }
it { expect(procedure.routing_enabled?).to be_truthy }
it "calls GroupeInstructeurMailer with the right params" do
it 'validates changes and responses' do
expect(gi_1_2.instructeurs.pluck(:email)).to include(*new_instructeur_emails)
expect(flash.notice).to be_present
expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_2))
expect(procedure.routing_enabled?).to be_truthy
expect(GroupeInstructeurMailer).to have_received(:notify_added_instructeurs).with(
gi_1_2,
[instructeur_email_verified],
@ -415,8 +431,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
context 'of badly formed email' do
let(:new_instructeur_emails) { ['badly_formed_email'] }
before { do_request }
it { expect(flash.alert).to be_present }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_2)) }
it do
expect(flash.alert).to be_present
expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_2))
end
end
context 'of an empty string' do
@ -460,10 +478,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
remove_instructeur(admin.instructeur)
end
it { expect(gi_1_1.instructeurs).to include(instructeur) }
it { expect(gi_1_1.reload.instructeurs.count).to eq(1) }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_1)) }
it "calls GroupeInstructeurMailer with the right groupe and instructeur" do
it 'verifies instructeurs and sends notifications' do
expect(gi_1_1.instructeurs).to include(instructeur)
expect(gi_1_1.reload.instructeurs.count).to eq(1)
expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_1))
expect(GroupeInstructeurMailer).to have_received(:notify_removed_instructeur).with(
gi_1_1,
admin.instructeur,
@ -478,10 +496,12 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
remove_instructeur(instructeur)
end
it { expect(gi_1_1.instructeurs).to include(instructeur) }
it { expect(gi_1_1.instructeurs.count).to eq(1) }
it { expect(flash.alert).to eq('Suppression impossible : il doit y avoir au moins un instructeur dans le groupe') }
it { expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_1)) }
it 'validates remaining instructeur and checks alert message' do
expect(gi_1_1.instructeurs).to include(instructeur)
expect(gi_1_1.instructeurs.count).to eq(1)
expect(flash.alert).to eq('Suppression impossible : il doit y avoir au moins un instructeur dans le groupe')
expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_1))
end
end
end
@ -496,19 +516,37 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
end
context 'when the instructor is assigned to the procedure' do
subject { delete :remove_instructeur, params: { instructeur: { id: instructeur_assigned_1.id }, procedure_id: procedure_non_routee.id, id: procedure_non_routee.defaut_groupe_instructeur.id } }
it { expect(subject.request.flash[:notice]).to be_present }
it { expect(subject.request.flash[:alert]).to be_nil }
it { expect(response.status).to eq(302) }
it { expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee) }
subject do
delete :remove_instructeur, params: {
instructeur: { id: instructeur_assigned_1.id },
procedure_id: procedure_non_routee.id,
id: procedure_non_routee.defaut_groupe_instructeur.id
}
end
it 'processes the removal of an assigned instructeur and checks response' do
expect(subject.request.flash[:notice]).to be_present
expect(subject.request.flash[:alert]).to be_nil
expect(response.status).to eq(302)
expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee)
end
end
context 'when the instructor is not assigned to the procedure' do
subject { delete :remove_instructeur, params: { instructeur: { id: instructeur_assigned_3.id }, procedure_id: procedure_non_routee.id, id: procedure_non_routee.defaut_groupe_instructeur.id } }
it { expect(subject.request.flash[:alert]).to be_present }
it { expect(subject.request.flash[:notice]).to be_nil }
it { expect(response.status).to eq(302) }
it { expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee) }
subject do
delete :remove_instructeur, params: {
instructeur: { id: instructeur_assigned_3.id },
procedure_id: procedure_non_routee.id,
id: procedure_non_routee.defaut_groupe_instructeur.id
}
end
it 'attempts to remove an unassigned instructeur and validates alerts' do
expect(subject.request.flash[:alert]).to be_present
expect(subject.request.flash[:notice]).to be_nil
expect(response.status).to eq(302)
expect(subject).to redirect_to admin_procedure_groupe_instructeurs_path(procedure_non_routee)
end
end
end
@ -523,10 +561,12 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect(response.status).to eq(302) }
it { expect(procedure.groupe_instructeurs.first.label).to eq("Afrique") }
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: kara") }
it 'checks multiple response aspects after CSV upload' do
expect(response.status).to eq(302)
expect(procedure.groupe_instructeurs.first.label).to eq("Afrique")
expect(flash.alert).to be_present
expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: kara")
end
end
context 'when the csv file has only one column' do
@ -534,10 +574,12 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect { subject }.not_to raise_error }
it { expect(response.status).to eq(302) }
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Importation impossible, veuillez importer un csv suivant <a href=\"/csv/import-instructeurs-test.csv\">ce modèle</a> pour une procédure sans routage ou <a href=\"/csv/fr/import-groupe-test.csv\">celui-ci</a> pour une procédure routée") }
it 'handles one column CSV file gracefully' do
expect { subject }.not_to raise_error
expect(response.status).to eq(302)
expect(flash.alert).to be_present
expect(flash.alert).to eq("Importation impossible, veuillez importer un csv suivant <a href=\"/csv/import-instructeurs-test.csv\">ce modèle</a> pour une procédure sans routage ou <a href=\"/csv/fr/import-groupe-test.csv\">celui-ci</a> pour une procédure routée")
end
end
context 'when the file content type is application/vnd.ms-excel' do
@ -545,8 +587,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect(flash.notice).to be_present }
it { expect(flash.notice).to eq("La liste des instructeurs a été importée avec succès") }
it 'imports excel file with success notice' do
expect(flash.notice).to be_present
expect(flash.notice).to eq("La liste des instructeurs a été importée avec succès")
end
end
context 'when the content of csv contains special characters' do
@ -558,10 +602,12 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
subject
end
it { expect(procedure.groupe_instructeurs.pluck(:label)).to match_array(["Auvergne-Rhône-Alpes", "Vendée", "défaut", "deuxième groupe"]) }
it { expect(flash.notice).to be_present }
it { expect(flash.notice).to eq("La liste des instructeurs a été importée avec succès") }
it { expect(GroupeInstructeurMailer).to have_received(:notify_added_instructeurs).twice }
it 'processes CSV with special characters and sends notifications' do
expect(procedure.groupe_instructeurs.pluck(:label)).to match_array(["Auvergne-Rhône-Alpes", "Vendée", "défaut", "deuxième groupe"])
expect(flash.notice).to be_present
expect(flash.notice).to eq("La liste des instructeurs a été importée avec succès")
expect(GroupeInstructeurMailer).to have_received(:notify_added_instructeurs).twice
end
end
context 'when the csv file length is more than 1 mo' do
@ -572,8 +618,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
subject
end
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Importation impossible : le poids du fichier est supérieur à 1 Mo") }
it 'verifies the file size limitation' do
expect(flash.alert).to be_present
expect(flash.alert).to eq("Importation impossible : le poids du fichier est supérieur à 1 Mo")
end
end
context 'when the file content type is not accepted' do
@ -581,8 +629,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Importation impossible : veuillez importer un fichier CSV") }
it 'checks file format acceptance' do
expect(flash.alert).to be_present
expect(flash.alert).to eq("Importation impossible : veuillez importer un fichier CSV")
end
end
context 'when the headers are wrong' do
@ -590,8 +640,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Importation impossible, veuillez importer un csv suivant <a href=\"/csv/import-instructeurs-test.csv\">ce modèle</a> pour une procédure sans routage ou <a href=\"/csv/fr/import-groupe-test.csv\">celui-ci</a> pour une procédure routée") }
it 'validates the header format of CSV' do
expect(flash.alert).to be_present
expect(flash.alert).to eq("Importation impossible, veuillez importer un csv suivant <a href=\"/csv/import-instructeurs-test.csv\">ce modèle</a> pour une procédure sans routage ou <a href=\"/csv/fr/import-groupe-test.csv\">celui-ci</a> pour une procédure routée")
end
end
context 'when procedure is closed' do
@ -600,8 +652,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect(procedure.groupe_instructeurs.first.label).to eq("Afrique") }
it { expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: kara") }
it 'handles imports with closed procedures' do
expect(procedure.groupe_instructeurs.first.label).to eq("Afrique")
expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: kara")
end
end
context 'when emails are invalid' do
@ -614,8 +668,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
subject
end
it { expect(flash.alert).to include("Import terminé. Cependant les emails suivants ne sont pas pris en compte:") }
it { expect(GroupeInstructeurMailer).not_to have_received(:notify_added_instructeurs) }
it 'manages CSV with invalid emails and checks for mailer action' do
expect(flash.alert).to include("Import terminé. Cependant les emails suivants ne sont pas pris en compte:")
expect(GroupeInstructeurMailer).not_to have_received(:notify_added_instructeurs)
end
end
end
@ -635,11 +691,11 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
subject
end
it { expect(response.status).to eq(302) }
it { expect(procedure_non_routee.instructeurs.pluck(:email)).to match_array(["kara@beta-gouv.fr", "philippe@mail.com", "lisa@gouv.fr"]) }
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: eric") }
it "calls GroupeInstructeurMailer" do
it 'verifies response status, updates instructors, and sends alerts with email issues' do
expect(response.status).to eq(302)
expect(procedure_non_routee.instructeurs.pluck(:email)).to match_array(["kara@beta-gouv.fr", "philippe@mail.com", "lisa@gouv.fr"])
expect(flash.alert).to be_present
expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: eric")
expect(GroupeInstructeurMailer).to have_received(:notify_added_instructeurs).with(
procedure_non_routee.defaut_groupe_instructeur,
any_args,
@ -653,19 +709,24 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect(response.status).to eq(302) }
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: kara") }
it { expect(procedure_non_routee.reload.routing_enabled?).to be_truthy }
it 'confirms multiple column CSV import, response, and routing changes' do
expect(response.status).to eq(302)
expect(flash.alert).to be_present
expect(flash.alert).to eq("Import terminé. Cependant les emails suivants ne sont pas pris en compte: kara")
expect(procedure_non_routee.reload.routing_enabled?).to be_truthy
end
end
context 'when the file content type is application/vnd.ms-excel' do
let(:csv_file) { fixture_file_upload('spec/fixtures/files/valid-instructeurs-file.csv', "application/vnd.ms-excel") }
before { subject }
it { expect(procedure_non_routee.instructeurs.pluck(:email)).to match_array(["kara@beta-gouv.fr", "philippe@mail.com", "lisa@gouv.fr"]) }
it { expect(flash.notice).to be_present }
it { expect(flash.notice).to eq("La liste des instructeurs a été importée avec succès") }
it 'handles excel file upload and verifies imported instructor emails' do
expect(procedure_non_routee.instructeurs.pluck(:email)).to match_array(["kara@beta-gouv.fr", "philippe@mail.com", "lisa@gouv.fr"])
expect(flash.notice).to be_present
expect(flash.notice).to eq("La liste des instructeurs a été importée avec succès")
end
end
context 'when the csv file length is more than 1 mo' do
@ -676,8 +737,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
subject
end
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Importation impossible : le poids du fichier est supérieur à 1 Mo") }
it 'checks for file size limit and displays appropriate flash alert' do
expect(flash.alert).to be_present
expect(flash.alert).to eq("Importation impossible : le poids du fichier est supérieur à 1 Mo")
end
end
context 'when the file content type is not accepted' do
@ -685,8 +748,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
before { subject }
it { expect(flash.alert).to be_present }
it { expect(flash.alert).to eq("Importation impossible : veuillez importer un fichier CSV") }
it 'validates file format and displays a flash alert' do
expect(flash.alert).to be_present
expect(flash.alert).to eq("Importation impossible : veuillez importer un fichier CSV")
end
end
context 'when emails are invalid' do
@ -698,8 +763,10 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
subject
end
it { expect(flash.alert).to include("Import terminé. Cependant les emails suivants ne sont pas pris en compte:") }
it { expect(GroupeInstructeurMailer).not_to have_received(:notify_added_instructeurs) }
it 'verifies email validity in CSV imports and checks for mailer not being called' do
expect(flash.alert).to include("Import terminé. Cependant les emails suivants ne sont pas pris en compte:")
expect(GroupeInstructeurMailer).not_to have_received(:notify_added_instructeurs)
end
end
end
end
@ -866,7 +933,9 @@ describe Administrateurs::GroupeInstructeursController, type: :controller do
}
}
it { expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_1)) }
it { expect(gi_1_1.signature).to be_attached }
it do
expect(response).to redirect_to(admin_procedure_groupe_instructeur_path(procedure, gi_1_1))
expect(gi_1_1.signature).to be_attached
end
end
end

2
spec/controllers/administrateurs/jeton_particulier_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::JetonParticulierController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure, administrateur: admin) }
before do

2
spec/controllers/administrateurs/mail_templates_controller_spec.rb
View file

@ -3,7 +3,7 @@ describe Administrateurs::MailTemplatesController, type: :controller do
let(:procedure) { create :procedure }
let(:initiated_mail) { Mails::InitiatedMail.default_for_procedure(procedure) }
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
before do
sign_in(procedure.administrateurs.first.user)

4
spec/controllers/administrateurs/procedure_administrateurs_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::ProcedureAdministrateursController, type: :controller do
let(:signed_in_admin) { create(:administrateur).tap { _1.user.update(last_sign_in_at: Time.zone.now) } }
let(:signed_in_admin) { administrateurs(:default_admin).tap { _1.user.update(last_sign_in_at: Time.zone.now) } }
let(:other_admin) { create(:administrateur).tap { _1.user.update(last_sign_in_at: Time.zone.now) } }
let!(:administrateurs_procedure) { create(:administrateurs_procedure, administrateur: signed_in_admin, procedure: procedure, manager: manager) }
let!(:procedure) { create(:procedure, administrateurs: [other_admin]) }
@ -12,7 +12,7 @@ describe Administrateurs::ProcedureAdministrateursController, type: :controller
describe '#create' do
context 'as manager' do
let(:manager) { true }
subject { post :create, params: { procedure_id: procedure.id, administrateur: { email: create(:administrateur).email } }, format: :turbo_stream }
subject { post :create, params: { procedure_id: procedure.id, administrateur: { email: administrateurs(:default_admin).email } }, format: :turbo_stream }
it { is_expected.to have_http_status(:forbidden) }
end
end

152
spec/controllers/administrateurs/procedures_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::ProceduresController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:bad_procedure_id) { 100000 }
let(:path) { 'ma-jolie-demarche' }
@ -124,8 +124,8 @@ describe Administrateurs::ProceduresController, type: :controller do
context 'for default admin 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]) }
let!(:procedure1) { create(:procedure, :published, :new_administrateur, zones: [zone1]) }
let!(:procedure2) { create(:procedure, :published, :new_administrateur, zones: [zone1, zone2]) }
let!(:admin_procedure) { create(:procedure, :published, zones: [zone2], administrateur: admin) }
subject { get :all, params: { zone_ids: :admin_default } }
@ -384,16 +384,15 @@ describe Administrateurs::ProceduresController, type: :controller do
let!(:large_closed_procedure) { create(:procedure_with_dossiers, :closed, dossiers_count: 2) }
let!(:small_closed_procedure) { create(:procedure_with_dossiers, :closed, dossiers_count: 1) }
it 'displays published and closed procedures' do
it 'displays expected procedures' do
# published and closed procedures' do
expect(response_procedures).to include(large_published_procedure)
expect(response_procedures).to include(large_closed_procedure)
end
it 'doesn’t display procedures without a significant number of dossiers' do
# doesn’t display procedures without a significant number of dossiers'
expect(response_procedures).not_to include(small_closed_procedure)
end
it 'doesn’t display draft procedures' do
# doesn’t display draft procedures'
expect(response_procedures).not_to include(large_draft_procedure)
end
end
@ -486,19 +485,19 @@ describe Administrateurs::ProceduresController, type: :controller do
post :create, params: { procedure: procedure_params }
end
describe 'procedure attributs in database' do
subject { Procedure.last }
it { expect(subject.libelle).to eq(libelle) }
it { expect(subject.description).to eq(description) }
it { expect(subject.organisation).to eq(organisation) }
it { expect(subject.administrateurs).to eq([admin]) }
it { expect(subject.duree_conservation_dossiers_dans_ds).to eq(duree_conservation_dossiers_dans_ds) }
it { expect(subject.tags).to eq(["planete", "environnement"]) }
end
it "create attributes" do
expect(subject.libelle).to eq(libelle)
expect(subject.description).to eq(description)
expect(subject.organisation).to eq(organisation)
expect(subject.administrateurs).to eq([admin])
expect(subject.duree_conservation_dossiers_dans_ds).to eq(duree_conservation_dossiers_dans_ds)
expect(subject.tags).to eq(["planete", "environnement"])
it { is_expected.to redirect_to(champs_admin_procedure_path(Procedure.last)) }
it { expect(flash[:notice]).to be_present }
expect(response).to redirect_to(champs_admin_procedure_path(Procedure.last))
expect(flash[:notice]).to be_present
end
end
describe "procedure is saved with custom retention period" do
@ -510,10 +509,9 @@ describe Administrateurs::ProceduresController, type: :controller do
subject { post :create, params: { procedure: procedure_params } }
it { expect { subject }.to change { Procedure.count }.by(1) }
it "must save retention period and max retention period" do
subject
expect { subject }.to change { Procedure.count }.by(1)
last_procedure = Procedure.last
expect(last_procedure.duree_conservation_dossiers_dans_ds).to eq(duree_conservation_dossiers_dans_ds)
expect(last_procedure.max_duree_conservation_dossiers_dans_ds).to eq(Expired::DEFAULT_DOSSIER_RENTENTION_IN_MONTH)
@ -589,15 +587,19 @@ describe Administrateurs::ProceduresController, type: :controller do
describe 'procedure attributs in database' do
subject { procedure }
it { expect(subject.libelle).to eq(libelle) }
it { expect(subject.description).to eq(description) }
it { expect(subject.organisation).to eq(organisation) }
it { expect(subject.duree_conservation_dossiers_dans_ds).to eq(duree_conservation_dossiers_dans_ds) }
it { expect(subject.procedure_expires_when_termine_enabled).to eq(true) }
it "update attributes" do
expect(subject.libelle).to eq(libelle)
expect(subject.description).to eq(description)
expect(subject.organisation).to eq(organisation)
expect(subject.duree_conservation_dossiers_dans_ds).to eq(duree_conservation_dossiers_dans_ds)
expect(subject.procedure_expires_when_termine_enabled).to eq(true)
end
end
it { is_expected.to redirect_to(admin_procedure_path id: procedure.id) }
it { expect(flash[:notice]).to be_present }
it do
is_expected.to redirect_to(admin_procedure_path id: procedure.id)
expect(flash[:notice]).to be_present
end
end
context 'when many attributs are not valid' do
@ -629,11 +631,11 @@ describe Administrateurs::ProceduresController, type: :controller do
subject { update_procedure }
describe 'only some properties can be updated' do
it { expect(subject.libelle).to eq procedure_params[:libelle] }
it { expect(subject.description).to eq procedure_params[:description] }
it { expect(subject.organisation).to eq procedure_params[:organisation] }
it { expect(subject.for_individual).not_to eq procedure_params[:for_individual] }
it 'only some properties can be updated' do
expect(subject.libelle).to eq procedure_params[:libelle]
expect(subject.description).to eq procedure_params[:description]
expect(subject.organisation).to eq procedure_params[:organisation]
expect(subject.for_individual).not_to eq procedure_params[:for_individual]
end
end
end
@ -673,7 +675,7 @@ describe Administrateurs::ProceduresController, type: :controller do
end
context 'when admin is not the owner of the procedure' do
let(:admin_2) { create(:administrateur) }
let(:admin_2) { administrateurs(:default_admin) }
before do
sign_out(admin.user)
@ -688,7 +690,7 @@ describe Administrateurs::ProceduresController, type: :controller do
end
context 'when procedure has invalid fields' do
let(:admin_2) { create(:administrateur) }
let(:admin_2) { administrateurs(:default_admin) }
let(:path) { 'spec/fixtures/files/invalid_file_format.json' }
before do
@ -915,7 +917,7 @@ describe Administrateurs::ProceduresController, type: :controller do
end
context "when administrateur does not own the procedure" do
let(:dossier) { create(:dossier) }
let(:dossier) { create(:dossier, procedure: create(:procedure, :new_administrateur)) }
it { expect { subject }.to raise_error(ActiveRecord::RecordNotFound) }
end
@ -955,30 +957,26 @@ describe Administrateurs::ProceduresController, type: :controller do
context 'when all attributes are present' do
render_views
before { update_monavis }
subject { update_monavis }
context 'when the embed code is valid' do
describe 'the monavis field is updated' do
subject { procedure }
it 'the monavis field is updated' do
subject
it { expect(subject.monavis_embed).to eq(monavis_embed) }
expect(procedure.monavis_embed).to eq(monavis_embed)
expect(flash[:notice]).to be_present
expect(response).to redirect_to(admin_procedure_path(procedure.id))
end
it { expect(flash[:notice]).to be_present }
it { expect(response).to redirect_to(admin_procedure_path(procedure.id)) }
end
context 'when the embed code is not valid' do
let(:monavis_embed) { 'invalid embed code' }
describe 'the monavis field is not updated' do
subject { procedure }
it { expect(subject.monavis_embed).to eq(nil) }
it 'the monavis field is not updated' do
expect(subject.monavis_embed).to eq(nil)
expect(flash[:alert]).to be_present
expect(response.body).to include "MonAvis"
end
it { expect(flash[:alert]).to be_present }
it { expect(response.body).to include "MonAvis" }
end
end
@ -1016,26 +1014,32 @@ describe Administrateurs::ProceduresController, type: :controller do
context 'when jeton is valid' do
let(:token_is_valid) { true }
it { expect(flash.alert).to be_nil }
it { expect(flash.notice).to eq('Le jeton a bien été mis à jour') }
it { expect(procedure.reload.api_entreprise_token).to eq(token) }
it do
expect(flash.alert).to be_nil
expect(flash.notice).to eq('Le jeton a bien été mis à jour')
expect(procedure.reload.api_entreprise_token).to eq(token)
end
end
context 'when jeton is invalid' do
let(:token_is_valid) { false }
it { expect(flash.alert).to eq("Mise à jour impossible : le jeton n’est pas valide") }
it { expect(flash.notice).to be_nil }
it { expect(procedure.reload.api_entreprise_token).not_to eq(token) }
it do
expect(flash.alert).to eq("Mise à jour impossible : le jeton n’est pas valide")
expect(flash.notice).to be_nil
expect(procedure.reload.api_entreprise_token).not_to eq(token)
end
end
context 'when jeton is not a jwt' do
let(:token) { "invalid" }
let(:token_is_valid) { true } # just to check jwt format by procedure model
it { expect(flash.alert).to eq("Mise à jour impossible : le jeton n’est pas valide") }
it { expect(flash.notice).to be_nil }
it { expect(procedure.reload.api_entreprise_token).not_to eq(token) }
it do
expect(flash.alert).to eq("Mise à jour impossible : le jeton n’est pas valide")
expect(flash.notice).to be_nil
expect(procedure.reload.api_entreprise_token).not_to eq(token)
end
end
end
@ -1068,7 +1072,7 @@ describe Administrateurs::ProceduresController, type: :controller do
describe 'PUT #publish' do
let(:procedure) { create(:procedure, administrateur: admin, lien_site_web: lien_site_web) }
let(:procedure2) { create(:procedure, :published, administrateur: admin, lien_site_web: lien_site_web) }
let(:procedure3) { create(:procedure, :published, lien_site_web: lien_site_web) }
let(:procedure3) { create(:procedure, :published, :new_administrateur, lien_site_web: lien_site_web) }
let(:lien_site_web) { 'http://some.administration/' }
subject(:perform_request) { put :publish, params: { procedure_id: procedure.id, path: path, lien_site_web: lien_site_web } }
@ -1221,10 +1225,12 @@ describe Administrateurs::ProceduresController, type: :controller do
context 'when admin is unknow' do
let(:email_admin) { 'plop' }
it { expect(subject.status).to eq 302 }
it { expect(response.body).to include(admin_procedure_transfert_path(procedure.id)) }
it { expect(flash[:alert]).to be_present }
it { expect(flash[:alert]).to eq("Envoi vers #{email_admin} impossible : cet administrateur n’existe pas") }
it do
expect(subject.status).to eq 302
expect(response.body).to include(admin_procedure_transfert_path(procedure.id))
expect(flash[:alert]).to be_present
expect(flash[:alert]).to eq("Envoi vers #{email_admin} impossible : cet administrateur n’existe pas")
end
end
context 'when admin is known' do
@ -1233,8 +1239,10 @@ describe Administrateurs::ProceduresController, type: :controller do
context "and its email address is correct" do
let(:email_admin) { 'new_admin@admin.com' }
it { expect(subject.status).to eq 302 }
it { expect { subject }.to change(new_admin.procedures, :count).by(1) }
it do
expect { subject }.to change(new_admin.procedures, :count).by(1)
expect(subject.status).to eq 302
end
it "should create a new service" do
subject
@ -1245,8 +1253,10 @@ describe Administrateurs::ProceduresController, type: :controller do
context 'when admin is know but its email was not downcased' do
let(:email_admin) { "NEW_admin@adMIN.com" }
it { expect(subject.status).to eq 302 }
it { expect { subject }.to change(Procedure, :count).by(1) }
it do
expect { subject }.to change(Procedure, :count).by(1)
expect(subject.status).to eq 302
end
end
describe "correctly assigns the new admin" do
@ -1308,8 +1318,10 @@ describe Administrateurs::ProceduresController, type: :controller do
procedure.reload
end
it { expect(procedure.discarded?).to be_falsy }
it { expect(procedure.dossiers.first.hidden_by_administration_at).to be_nil }
it do
expect(procedure.discarded?).to be_falsy
expect(procedure.dossiers.first.hidden_by_administration_at).to be_nil
end
end
end
end

4
spec/controllers/administrateurs/services_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::ServicesController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure, administrateur: admin) }
describe '#create' do
@ -159,7 +159,7 @@ describe Administrateurs::ServicesController, type: :controller do
end
describe "#index" do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
before do
sign_in(admin.user)

2
spec/controllers/administrateurs/sources_particulier_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe Administrateurs::SourcesParticulierController, type: :controller do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
before { sign_in(admin.user) }

4
spec/controllers/api/v1/dossiers_controller_spec.rb
View file

@ -1,8 +1,8 @@
describe API::V1::DossiersController do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:token) { APIToken.generate(admin)[1] }
let(:procedure) { create(:procedure, :with_type_de_champ, :with_type_de_champ_private, administrateur: admin) }
let(:wrong_procedure) { create(:procedure) }
let(:wrong_procedure) { create(:procedure, :new_administrateur) }
it { expect(described_class).to be < APIController }

2
spec/controllers/api/v2/base_controller_spec.rb
View file

@ -1,6 +1,6 @@
describe API::V2::BaseController, type: :controller do
describe 'ensure_authorized_network and token_is_not_expired' do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:token_bearer_couple) { APIToken.generate(admin) }
let(:token) { token_bearer_couple[0] }
let(:bearer) { token_bearer_couple[1] }

2
spec/controllers/api/v2/graphql_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe API::V2::GraphqlController do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:generated_token) { APIToken.generate(admin) }
let(:api_token) { generated_token.first }
let(:token) { generated_token.second }

4
spec/controllers/api/v2/graphql_controller_stored_queries_spec.rb
View file

@ -1,5 +1,5 @@
describe API::V2::GraphqlController do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:generated_token) { APIToken.generate(admin) }
let(:api_token) { generated_token.first }
let(:token) { generated_token.second }
@ -1386,7 +1386,7 @@ describe API::V2::GraphqlController do
}
context 'when unauthorized' do
let(:dossier) { create(:dossier, :en_construction, :with_individual) }
let(:dossier) { create(:dossier, :en_construction, :with_individual, procedure: create(:procedure, :new_administrateur, :for_individual)) }
it {
expect(message.discarded?).to be_falsey

2
spec/controllers/api_controller_spec.rb
View file

@ -41,7 +41,7 @@ describe APIController, type: :controller do
end
describe 'ensure_authorized_network and token is not expired' do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:token_bearer_couple) { APIToken.generate(admin) }
let(:token) { token_bearer_couple[0] }
let(:bearer) { token_bearer_couple[1] }

2
spec/controllers/application_controller_spec.rb
View file

@ -70,7 +70,7 @@ describe ApplicationController, type: :controller do
context 'when someone is logged as a user, instructeur, administrateur and super_admin' do
let(:current_user) { create(:user) }
let(:current_instructeur) { create(:instructeur) }
let(:current_administrateur) { create(:administrateur) }
let(:current_administrateur) { administrateurs(:default_admin) }
let(:current_super_admin) { create(:super_admin) }
it do

2
spec/controllers/data_sources/chorus_controller_spec.rb
View file

@ -1,5 +1,5 @@
describe DataSources::ChorusController do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
render_views

4
spec/controllers/gestionnaires/groupe_gestionnaire_administrateurs_controller_spec.rb
View file

@ -47,7 +47,7 @@ describe Gestionnaires::GroupeGestionnaireAdministrateursController, type: :cont
end
context 'when administrateur has some procedure' do
let(:administrateur_with_procedure) { create(:administrateur) }
let(:administrateur_with_procedure) { administrateurs(:default_admin) }
let!(:procedure) { create(:procedure_with_dossiers, administrateur: administrateur_with_procedure) }
before do
groupe_gestionnaire.administrateurs << administrateur_with_procedure
@ -59,7 +59,7 @@ describe Gestionnaires::GroupeGestionnaireAdministrateursController, type: :cont
end
context 'when administrateur is not in the groupe_gestionnaire' do
let(:other_administrateur) { create(:administrateur) }
let(:other_administrateur) { administrateurs(:default_admin) }
before { destroy(other_administrateur) }
it { expect(groupe_gestionnaire.reload.administrateurs.count).to eq(1) }

2
spec/controllers/gestionnaires/groupe_gestionnaire_commentaires_controller_spec.rb
View file

@ -1,6 +1,6 @@
describe Gestionnaires::GroupeGestionnaireCommentairesController, type: :controller do
let(:gestionnaire) { create(:gestionnaire).tap { _1.user.update(last_sign_in_at: Time.zone.now) } }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire], administrateurs: [administrateur]) }
let!(:commentaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur) }

9
spec/controllers/instructeurs/dossiers_controller_spec.rb
View file

@ -2,11 +2,10 @@ describe Instructeurs::DossiersController, type: :controller do
render_views
let(:instructeur) { create(:instructeur) }
let(:administrateur) { create(:administrateur) }
let(:administration) { create(:administration) }
let(:instructeurs) { [instructeur] }
let(:procedure) { create(:procedure, :published, :for_individual, instructeurs: instructeurs) }
let(:procedure_accuse_lecture) { create(:procedure, :published, :for_individual, :accuse_lecture, instructeurs: instructeurs) }
let(:procedure_accuse_lecture) { create(:procedure, :published, :for_individual, :accuse_lecture, :new_administrateur, instructeurs: instructeurs) }
let(:dossier) { create(:dossier, :en_construction, :with_individual, procedure: procedure) }
let(:dossier_accuse_lecture) { create(:dossier, :en_construction, :with_individual, procedure: procedure_accuse_lecture) }
let(:dossier_for_tiers) { create(:dossier, :en_construction, :for_tiers_with_notification, procedure: procedure) }
@ -1309,7 +1308,7 @@ describe Instructeurs::DossiersController, type: :controller do
describe '#reaffectation' do
let!(:gi_2) { GroupeInstructeur.create(label: 'deuxième groupe', procedure: procedure) }
let!(:gi_3) { GroupeInstructeur.create(label: 'troisième groupe', procedure: procedure) }
let!(:dossier) { create(:dossier, :en_construction, procedure: procedure, groupe_instructeur: procedure.groupe_instructeurs.first) }
let!(:dossier) { create(:dossier, :en_construction, procedure: procedure, groupe_instructeur: procedure.groupe_instructeurs.reorder(:id).first) }
before do
post :reaffectation,
@ -1361,8 +1360,8 @@ describe Instructeurs::DossiersController, type: :controller do
describe '#personnes_impliquees' do
let(:routed_procedure) { create(:procedure, :routee, :published, :for_individual) }
let(:gi_1) { routed_procedure.groupe_instructeurs.first }
let(:gi_2) { routed_procedure.groupe_instructeurs.last }
let(:gi_1) { routed_procedure.groupe_instructeurs.reorder(:id).first }
let(:gi_2) { routed_procedure.groupe_instructeurs.reorder(:id).last }
let(:dossier) { create(:dossier, :en_construction, :with_individual, procedure: routed_procedure, groupe_instructeur: gi_1) }
let(:new_instructeur) { create(:instructeur) }

74
spec/controllers/instructeurs/groupe_instructeurs_controller_spec.rb
View file

@ -32,34 +32,38 @@ describe Instructeurs::GroupeInstructeursController, type: :controller do
end
context 'when i am an instructeur of the procedure and instructeurs_self_management_enabled is true' do
let(:procedure) { create(:procedure, :published, administrateurs: [create(:administrateur)], instructeurs_self_management_enabled: true) }
let(:procedure) { create(:procedure, :published, instructeurs_self_management_enabled: true) }
before { get :index, params: { procedure_id: procedure.id } }
context 'when a procedure has multiple groups' do
it { expect(response).to have_http_status(:ok) }
it { expect(response.body).to include(gi_1_2.label) }
it { expect(response.body).not_to include(gi_1_1.label) }
it { expect(response.body).not_to include(gi_2_2.label) }
it 'when a procedure has multiple groups' do
expect(response).to have_http_status(:ok)
expect(response.body).to include(gi_1_2.label)
expect(response.body).not_to include(gi_1_1.label)
expect(response.body).not_to include(gi_2_2.label)
end
end
context 'when i am an instructor of the procedure, and instructeurs_self_management_enabled is false' do
let(:procedure) { create(:procedure, :published, administrateurs: [create(:administrateur)], instructeurs_self_management_enabled: false) }
let(:procedure) { create(:procedure, :published, :new_administrateur, instructeurs_self_management_enabled: false) }
before { get :index, params: { procedure_id: procedure.id } }
it { expect(response).to have_http_status(:redirect) }
it { expect(flash.alert).to eq("Vous n’avez pas le droit de gérer les instructeurs de cette démarche") }
it "works" do
expect(response).to have_http_status(:redirect)
expect(flash.alert).to eq("Vous n’avez pas le droit de gérer les instructeurs de cette démarche")
end
end
context 'i am an instructor, not on the procedure' do
let(:procedure) { create(:procedure, :published, administrateurs: [create(:administrateur)], instructeurs_self_management_enabled: true) }
let(:procedure) { create(:procedure, :published, :new_administrateur, instructeurs_self_management_enabled: true) }
before do
sign_in(create(:instructeur).user)
get :index, params: { procedure_id: procedure.id }
end
it { expect(response).to have_http_status(:redirect) }
it { expect(flash.alert).to eq("Vous n’avez pas accès à cette démarche") }
it "works" do
expect(response).to have_http_status(:redirect)
expect(flash.alert).to eq("Vous n’avez pas accès à cette démarche")
end
end
end
@ -85,24 +89,30 @@ describe Instructeurs::GroupeInstructeursController, type: :controller do
let(:new_instructeur_email) { 'new_instructeur@mail.com' }
before { subject }
it { expect(gi_1_2.instructeurs.map(&:email)).to include(new_instructeur_email) }
it { expect(flash.notice).to be_present }
it { expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_2)) }
it "works" do
expect(gi_1_2.instructeurs.map(&:email)).to include(new_instructeur_email)
expect(flash.notice).to be_present
expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_2))
end
end
context 'of an instructeur already in the group' do
let(:new_instructeur_email) { instructeur.email }
before { subject }
it { expect(flash.alert).to be_present }
it { expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_2)) }
it "works" do
expect(flash.alert).to be_present
expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_2))
end
end
context 'invalid email' do
let(:new_instructeur_email) { 'invalid' }
it { subject; expect(flash.alert).to include(new_instructeur_email) }
it { expect { subject }.not_to enqueue_email }
it "works" do
expect { subject }.not_to enqueue_email
expect(flash.alert).to include(new_instructeur_email)
end
end
end
@ -128,10 +138,12 @@ describe Instructeurs::GroupeInstructeursController, type: :controller do
context 'when there are many instructeurs' do
before { remove_instructeur(new_instructeur) }
it { expect(gi_1_1.instructeurs).to include(instructeur) }
it { expect(gi_1_1.reload.instructeurs.count).to eq(1) }
it { expect(new_instructeur.reload.follows.count).to eq(0) }
it { expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_1)) }
it "works" do
expect(gi_1_1.instructeurs).to include(instructeur)
expect(gi_1_1.reload.instructeurs.count).to eq(1)
expect(new_instructeur.reload.follows.count).to eq(0)
expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_1))
end
end
context 'when there is only one instructeur' do
@ -140,10 +152,12 @@ describe Instructeurs::GroupeInstructeursController, type: :controller do
remove_instructeur(instructeur)
end
it { expect(gi_1_1.instructeurs).to include(instructeur) }
it { expect(gi_1_1.instructeurs.count).to eq(1) }
it { expect(flash.alert).to eq('Suppression impossible : il doit y avoir au moins un instructeur dans le groupe') }
it { expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_1)) }
it "works" do
expect(gi_1_1.instructeurs).to include(instructeur)
expect(gi_1_1.instructeurs.count).to eq(1)
expect(flash.alert).to eq('Suppression impossible : il doit y avoir au moins un instructeur dans le groupe')
expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_1))
end
end
end
@ -161,7 +175,9 @@ describe Instructeurs::GroupeInstructeursController, type: :controller do
}
end
it { expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_2)) }
it { expect(gi_1_2.reload.signature).to be_attached }
it "works" do
expect(response).to redirect_to(instructeur_groupe_path(procedure, gi_1_2))
expect(gi_1_2.reload.signature).to be_attached
end
end
end

2
spec/controllers/manager/administrateurs_controller_spec.rb
View file

@ -1,6 +1,6 @@
describe Manager::AdministrateursController, type: :controller do
let(:super_admin) { create(:super_admin) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before do
sign_in super_admin

2
spec/controllers/manager/procedures_controller_spec.rb
View file

@ -1,7 +1,7 @@
describe Manager::ProceduresController, type: :controller do
let(:super_admin) { create :super_admin }
let(:administrateur) { create(:administrateur, email: super_admin.email) }
let(:autre_administrateur) { create(:administrateur) }
let(:autre_administrateur) { administrateurs(:default_admin) }
before { sign_in super_admin }
describe '#whitelist' do

2
spec/controllers/root_controller_spec.rb
View file

@ -34,7 +34,7 @@ describe RootController, type: :controller do
context 'when Administrateur is connected' do
before do
sign_in(create(:administrateur).user)
sign_in(administrateurs(:default_admin).user)
end
it { expect(subject).to redirect_to(admin_procedures_path) }

2
spec/factories/administrateurs_procedure.rb
View file

@ -1,6 +1,6 @@
FactoryBot.define do
factory :administrateurs_procedure do
association :administrateur
administrateur { Administrateur.find_by(user: { email: "default_admin@admin.com" }) }
association :procedure
end
end

24
spec/factories/batch_operation.rb
View file

@ -9,7 +9,7 @@ FactoryBot.define do
trait :archiver do
operation { BatchOperation.operations.fetch(:archiver) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :accepte, procedure: procedure),
create(:dossier, :with_individual, :refuse, procedure: procedure),
@ -21,7 +21,7 @@ FactoryBot.define do
trait :desarchiver do
operation { BatchOperation.operations.fetch(:desarchiver) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :accepte, procedure: procedure, archived: true),
create(:dossier, :with_individual, :refuse, procedure: procedure, archived: true),
@ -33,7 +33,7 @@ FactoryBot.define do
trait :passer_en_instruction do
operation { BatchOperation.operations.fetch(:passer_en_instruction) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :en_construction, procedure: procedure),
create(:dossier, :with_individual, :en_construction, procedure: procedure)
@ -44,7 +44,7 @@ FactoryBot.define do
trait :repousser_expiration do
operation { BatchOperation.operations.fetch(:repousser_expiration) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :accepte, procedure: procedure, processed_at: 12.months.ago),
create(:dossier, :with_individual, :accepte, procedure: procedure, processed_at: 12.months.ago)
@ -55,7 +55,7 @@ FactoryBot.define do
trait :accepter do
operation { BatchOperation.operations.fetch(:accepter) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :en_instruction, procedure: procedure),
create(:dossier, :with_individual, :en_instruction, procedure: procedure)
@ -66,7 +66,7 @@ FactoryBot.define do
trait :refuser do
operation { BatchOperation.operations.fetch(:refuser) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :en_instruction, procedure: procedure),
create(:dossier, :with_individual, :en_instruction, procedure: procedure)
@ -77,7 +77,7 @@ FactoryBot.define do
trait :classer_sans_suite do
operation { BatchOperation.operations.fetch(:classer_sans_suite) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :en_instruction, procedure: procedure),
create(:dossier, :with_individual, :en_instruction, procedure: procedure)
@ -88,7 +88,7 @@ FactoryBot.define do
trait :follow do
operation { BatchOperation.operations.fetch(:follow) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :en_instruction, procedure: procedure),
create(:dossier, :with_individual, :en_construction, procedure: procedure)
@ -99,7 +99,7 @@ FactoryBot.define do
trait :unfollow do
operation { BatchOperation.operations.fetch(:unfollow) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :en_instruction, procedure: procedure, followers_instructeurs: procedure.instructeurs),
create(:dossier, :with_individual, :en_construction, procedure: procedure, followers_instructeurs: procedure.instructeurs)
@ -110,7 +110,7 @@ FactoryBot.define do
trait :restaurer do
operation { BatchOperation.operations.fetch(:restaurer) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :accepte, procedure: procedure, hidden_by_administration_at: Time.zone.now),
create(:dossier, :with_individual, :refuse, procedure: procedure, hidden_by_administration_at: Time.zone.now)
@ -121,7 +121,7 @@ FactoryBot.define do
trait :repasser_en_construction do
operation { BatchOperation.operations.fetch(:repasser_en_construction) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :en_instruction, procedure: procedure),
create(:dossier, :with_individual, :en_instruction, procedure: procedure)
@ -132,7 +132,7 @@ FactoryBot.define do
trait :supprimer do
operation { BatchOperation.operations.fetch(:supprimer) }
after(:build) do |batch_operation, evaluator|
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur], administrateurs: [create(:administrateur)])
procedure = create(:simple_procedure, :published, instructeurs: [evaluator.invalid_instructeur.presence || batch_operation.instructeur])
batch_operation.dossiers = [
create(:dossier, :with_individual, :accepte, procedure: procedure),
create(:dossier, :with_individual, :refuse, procedure: procedure)

14
spec/factories/procedure.rb
View file

@ -17,10 +17,14 @@ FactoryBot.define do
sva_svr { {} }
groupe_instructeurs { [association(:groupe_instructeur, :default, procedure: instance, strategy: :build)] }
administrateurs { administrateur.present? ? [administrateur] : [association(:administrateur)] }
administrateurs { [administrateur] }
trait(:new_administrateur) do
administrateur { create(:administrateur) }
end
transient do
administrateur {}
administrateur { Administrateur.find_by(user: { email: "default_admin@admin.com" }) }
instructeurs { [] }
types_de_champ_public { [] }
types_de_champ_private { [] }
@ -79,10 +83,8 @@ FactoryBot.define do
end
after(:create) do |procedure, evaluator|
user = create(:user)
evaluator.dossiers_count.times do
create(:dossier, procedure: procedure, user: user)
end
user = User.find_by(email: "default_user@user.com")
create_list(:dossier, evaluator.dossiers_count, procedure: procedure, user: user)
end
end

2
spec/fixtures/administrateurs.yml vendored Normal file
View file

@ -0,0 +1,2 @@
default_admin:
user: default_user_admin

3
spec/fixtures/instructeurs.yml vendored Normal file
View file

@ -0,0 +1,3 @@
default_instructeur_admin:
user: default_user_admin
bypass_email_login_token: true

9
spec/fixtures/users.yml vendored Normal file
View file

@ -0,0 +1,9 @@
default_user:
email: default_user@user.com
encrypted_password: <%= Devise::Encryptor.digest(User, '{My-$3cure-p4ssWord}') %>
confirmed_at: <%= Time.current.to_s(:db) %>
default_user_admin:
email: default_admin@admin.com
encrypted_password: <%= Devise::Encryptor.digest(User, '{My-$3cure-p4ssWord}') %>
confirmed_at: <%= Time.current.to_s(:db) %>

2
spec/graphql/annotation_spec.rb
View file

@ -1,5 +1,5 @@
RSpec.describe Mutations::DossierModifierAnnotation, type: :graphql do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure, :published, :for_individual, types_de_champ_private: [{ type: :repetition, children: [{ libelle: 'Nom' }, { type: :integer_number, libelle: 'Age' }] }, {}], administrateurs: [admin]) }
let(:dossiers) { [] }
let(:instructeur) { create(:instructeur, followed_dossiers: dossiers) }

2
spec/graphql/demarche_spec.rb
View file

@ -1,5 +1,5 @@
RSpec.describe Types::DemarcheType, type: :graphql do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:query) { '' }
let(:context) { { procedure_ids: admin.procedure_ids } }
let(:variables) { {} }

2
spec/jobs/cron/administrateur_activate_before_expiration_job_spec.rb
View file

@ -1,6 +1,6 @@
RSpec.describe Cron::AdministrateurActivateBeforeExpirationJob, type: :job do
describe 'perform' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:user) { administrateur.user }
let(:mailer_double) { double('mailer', deliver_later: true) }

10
spec/jobs/cron/purge_manager_administrateur_sessions_job_spec.rb
View file

@ -8,14 +8,14 @@ RSpec.describe Cron::PurgeManagerAdministrateurSessionsJob, type: :job do
context "with an inactive administrateur" do
before do
AdministrateursProcedure.create(procedure: procedure, administrateur: administrateur, manager: true)
expect(AdministrateursProcedure.where(manager: true).count).to eq(1)
expect(AdministrateursProcedure.count).to eq(2)
subject
end
it {
expect(AdministrateursProcedure.where(manager: true).count).to eq(0)
expect(AdministrateursProcedure.count).to eq(1)
expect(AdministrateursProcedure.where(procedure:, manager: true).count).to eq(1)
expect(AdministrateursProcedure.where(procedure:).count).to eq(2)
subject
expect(AdministrateursProcedure.where(procedure:, manager: true).count).to eq(0)
expect(AdministrateursProcedure.where(procedure:).count).to eq(1)
}
end
end

2
spec/jobs/cron/send_api_token_expiration_notice_job_spec.rb
View file

@ -1,6 +1,6 @@
RSpec.describe Cron::SendAPITokenExpirationNoticeJob, type: :job do
describe 'perform' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let!(:token) { APIToken.generate(administrateur).first }
let(:mailer_double) { double('mailer', deliver_later: true) }
let(:today) { Date.new(2018, 01, 01) }

6
spec/jobs/cron/weekly_overview_job_spec.rb
View file

@ -21,8 +21,10 @@ RSpec.describe Cron::WeeklyOverviewJob, type: :job do
run_job
end
it { expect(InstructeurMailer).to have_received(:last_week_overview).with(instructeur) }
it { expect(mailer_double).to have_received(:deliver_later) }
it do
expect(InstructeurMailer).to have_received(:last_week_overview).with(instructeur)
expect(mailer_double).to have_received(:deliver_later).at_least(1).times
end
end
context 'with one instructeur with no overviews' do

2
spec/lib/active_storage/downloadable_file_spec.rb
View file

@ -1,6 +1,6 @@
describe ActiveStorage::DownloadableFile do
let(:dossier) { create(:dossier, :en_construction) }
let(:user_profile) { create(:administrateur) }
let(:user_profile) { administrateurs(:default_admin) }
let(:dossiers) { Dossier.where(id: dossier.id) }
subject(:list) { ActiveStorage::DownloadableFile.create_list_from_dossiers(user_profile:, dossiers:) }

2
spec/lib/tasks/clean_services_spec.rb
View file

@ -24,7 +24,7 @@ describe 'service tasks' do
describe 'service:notify_no_siret' do
let(:task) { 'service:email_no_siret' }
let!(:procedure_without_siret_service) { create(:procedure, :published, service: service, administrateur: administrateur) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:service) do
s = build(:service, siret: nil, administrateur: administrateur)
s.save(validate: false)

2
spec/lib/tasks/re_routing_dossiers_spec.rb
View file

@ -2,7 +2,7 @@ describe 're_routing_dossiers' do
describe 'run' do
include Logic
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure, types_de_champ_public: [{ type: :departements, libelle: 'Votre département' }], administrateurs: [admin]) }
let(:dossier1) { create(:dossier, :en_construction, :with_populated_champs, procedure: procedure) }
let!(:dossier2) { create(:dossier, :en_construction, :with_populated_champs, procedure: procedure) }

2
spec/lib/tasks/support_spec.rb
View file

@ -10,7 +10,7 @@ describe 'support' do
after { rake_task.reenable }
# the admin to remove
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
# the super admin doing the removal
let(:super_admin) { create(:super_admin) }

2
spec/mailers/notification_mailer_spec.rb
View file

@ -1,5 +1,5 @@
RSpec.describe NotificationMailer, type: :mailer do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:user) { create(:user) }
let(:procedure) { create(:simple_procedure, :with_service) }

4
spec/mailers/user_mailer_spec.rb
View file

@ -114,7 +114,7 @@ RSpec.describe UserMailer, type: :mailer do
end
context 'administrateur' do
let(:role) { create(:administrateur) }
let(:role) { administrateurs(:default_admin) }
it 'sends email with correct links to administrateur' do
expect(subject.to).to eq([role.user.email])
expect(subject.body).to have_link('Consulter mes archives', href: admin_procedure_archives_url(procedure, host: ENV.fetch("APP_HOST_LEGACY")))
@ -123,7 +123,7 @@ RSpec.describe UserMailer, type: :mailer do
end
context 'when perform_later is called' do
let(:role) { create(:administrateur) }
let(:role) { administrateurs(:default_admin) }
let(:custom_queue) { 'low_priority' }
before { ENV['BULK_EMAIL_QUEUE'] = custom_queue }
it 'enqueues email is custom queue for low priority delivery' do

41
spec/models/administrateur_spec.rb
View file

@ -1,19 +1,19 @@
describe Administrateur, type: :model do
let(:administration) { create(:administration) }
describe 'associations' do
it { is_expected.to have_many(:commentaire_groupe_gestionnaires) }
it { is_expected.to have_many(:archives) }
it { is_expected.to have_many(:exports) }
it { is_expected.to have_and_belong_to_many(:instructeurs) }
it { is_expected.to belong_to(:groupe_gestionnaire).optional }
it 'define associations' do
is_expected.to have_many(:commentaire_groupe_gestionnaires)
is_expected.to have_many(:archives)
is_expected.to have_many(:exports)
is_expected.to have_and_belong_to_many(:instructeurs)
is_expected.to belong_to(:groupe_gestionnaire).optional
end
describe "#can_be_deleted?" do
subject { administrateur.can_be_deleted? }
context "when the administrateur's procedures have other administrateurs" do
let!(:administrateur) { create(:administrateur) }
let!(:administrateur) { administrateurs(:default_admin) }
let!(:autre_administrateur) { create(:administrateur) }
let!(:procedure) { create(:procedure, administrateurs: [administrateur, autre_administrateur]) }
@ -21,14 +21,14 @@ describe Administrateur, type: :model do
end
context "when the administrateur has a procedure with dossiers where they is the only admin" do
let!(:administrateur) { create(:administrateur) }
let!(:administrateur) { administrateurs(:default_admin) }
let!(:procedure) { create(:procedure_with_dossiers, administrateurs: [administrateur]) }
it { is_expected.to be false }
end
context "when the administrateur has a procedure with dossiers and with other admins" do
let!(:administrateur) { create(:administrateur) }
let!(:administrateur) { administrateurs(:default_admin) }
let!(:administrateur2) { create(:administrateur) }
let!(:procedure) { create(:procedure_with_dossiers, administrateurs: [administrateur, administrateur2]) }
@ -36,21 +36,21 @@ describe Administrateur, type: :model do
end
context "when the administrateur has a procedure without dossiers" do
let!(:administrateur) { create(:administrateur) }
let!(:administrateur) { administrateurs(:default_admin) }
let!(:procedure) { create(:procedure, administrateurs: [administrateur]) }
it { is_expected.to be true }
end
context "when the administrateur has no procedure" do
let!(:administrateur) { create(:administrateur) }
let!(:administrateur) { administrateurs(:default_admin) }
it { is_expected.to be true }
end
end
describe '#merge' do
let(:new_admin) { create(:administrateur) }
let(:new_admin) { administrateurs(:default_admin) }
let(:old_admin) { create(:administrateur) }
subject { new_admin.merge(old_admin) }
@ -78,14 +78,7 @@ describe Administrateur, type: :model do
end
context 'when both admins share a procedure' do
let(:procedure) { create(:procedure) }
before do
new_admin.procedures << procedure
old_admin.procedures << procedure
subject
[new_admin, old_admin].map(&:reload)
end
let(:procedure) { create(:procedure, administrateurs: [old_admin, new_admin]) }
it 'removes the procedure from the old one' do
expect(old_admin.procedures).to be_empty
@ -185,7 +178,7 @@ describe Administrateur, type: :model do
describe 'unused' do
subject { Administrateur.unused }
let(:new_admin) { create(:administrateur) }
let(:new_admin) { administrateurs(:default_admin) }
let(:unused_admin) { create(:administrateur, :with_api_token) }
before do
@ -237,7 +230,7 @@ describe Administrateur, type: :model do
end
describe 'zones' do
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:zone1) { create(:zone) }
let(:zone2) { create(:zone) }
let!(:procedure) { create(:procedure, administrateurs: [admin], zones: [zone1, zone2]) }
@ -250,7 +243,7 @@ describe Administrateur, type: :model do
describe "#unread_commentaires?" do
context "commentaire_seen_at is nil" do
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, gestionnaire: gestionnaire, created_at: 12.hours.ago) }
@ -285,7 +278,7 @@ describe Administrateur, type: :model do
describe "#mark_commentaire_as_seen" do
let(:now) { Time.zone.now.beginning_of_minute }
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, created_at: 12.hours.ago) }

4
spec/models/api_token_spec.rb
View file

@ -1,5 +1,5 @@
describe APIToken, type: :model do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
describe '#generate' do
let(:api_token_and_packed_token) { APIToken.generate(administrateur) }
@ -59,7 +59,7 @@ describe APIToken, type: :model do
end
context 'but acces to a wrong procedure_id' do
let(:forbidden_procedure) { create(:procedure) }
let(:forbidden_procedure) { create(:procedure, :new_administrateur) }
before do
api_token.update(allowed_procedure_ids: [forbidden_procedure.id])

16
spec/models/commentaire_groupe_gestionnaire_spec.rb
View file

@ -9,7 +9,7 @@ describe CommentaireGroupeGestionnaire, type: :model do
let(:commentaire_groupe_gestionnaire) { create :commentaire_groupe_gestionnaire, sender: sender, gestionnaire: gestionnaire }
context 'when created by an administrateur' do
let(:sender) { create(:administrateur) }
let(:sender) { administrateurs(:default_admin) }
let(:gestionnaire) { nil }
it 'set correctly sender_email and gestionnaire_email' do
expect(commentaire_groupe_gestionnaire.sender_email).to eq(sender.email)
@ -18,7 +18,7 @@ describe CommentaireGroupeGestionnaire, type: :model do
end
context 'when answer by a gestionnaire' do
let(:sender) { create(:administrateur) }
let(:sender) { administrateurs(:default_admin) }
let(:gestionnaire) { create(:gestionnaire) }
it 'set correctly sender_email and gestionnaire_email' do
@ -34,7 +34,7 @@ describe CommentaireGroupeGestionnaire, type: :model do
let(:commentaire_groupe_gestionnaire) { build :commentaire_groupe_gestionnaire, sender: sender, gestionnaire: gestionnaire }
context 'with a commentaire_groupe_gestionnaire created by an administrateur deleted by administrateur' do
let(:sender) { create(:administrateur) }
let(:sender) { administrateurs(:default_admin) }
let(:user) { sender }
let(:gestionnaire) { nil }
@ -42,7 +42,7 @@ describe CommentaireGroupeGestionnaire, type: :model do
end
context 'with a commentaire_groupe_gestionnaire created by an administrateur deleted by gestionnaire' do
let(:sender) { create(:administrateur) }
let(:sender) { administrateurs(:default_admin) }
let(:user) { create(:gestionnaire) }
let(:gestionnaire) { nil }
@ -59,7 +59,7 @@ describe CommentaireGroupeGestionnaire, type: :model do
context 'with a commentaire_groupe_gestionnaire created by an gestionnaire deleted by administrateur' do
let(:sender) { create(:gestionnaire) }
let(:user) { create(:administrateur) }
let(:user) { administrateurs(:default_admin) }
let(:gestionnaire) { sender }
it { is_expected.to be_falsy }
@ -72,14 +72,14 @@ describe CommentaireGroupeGestionnaire, type: :model do
let(:commentaire_groupe_gestionnaire) { build :commentaire_groupe_gestionnaire, sender: sender }
context 'with a commentaire_groupe_gestionnaire created by an administrateur so sent by administrateur' do
let(:sender) { create(:administrateur) }
let(:sender) { administrateurs(:default_admin) }
let(:user) { sender }
it { is_expected.to be_truthy }
end
context 'with a commentaire_groupe_gestionnaire created by an administrateur so not sent by gestionnaire' do
let(:sender) { create(:administrateur) }
let(:sender) { administrateurs(:default_admin) }
let(:user) { create(:gestionnaire) }
it { is_expected.to be_falsy }
@ -94,7 +94,7 @@ describe CommentaireGroupeGestionnaire, type: :model do
context 'with a commentaire_groupe_gestionnaire created by an gestionnaire so not sent by administrateur' do
let(:sender) { create(:gestionnaire) }
let(:user) { create(:administrateur) }
let(:user) { administrateurs(:default_admin) }
it { is_expected.to be_falsy }
end

2
spec/models/concerns/initiation_procedure_concern_spec.rb
View file

@ -1,6 +1,6 @@
describe InitiationProcedureConcern do
describe '.create_initiation_procedure' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
subject { Procedure.create_initiation_procedure(administrateur) }
it "returns a new procedure" do

2
spec/models/dossier_spec.rb
View file

@ -1848,7 +1848,7 @@ describe Dossier, type: :model do
end
describe 'brouillon_expired and en_construction_expired' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:user) { administrateur.user }
let(:reason) { DeletedDossier.reasons.fetch(:user_request) }

16
spec/models/gestionnaire_spec.rb
View file

@ -83,18 +83,18 @@ describe Gestionnaire, type: :model do
describe "#unread_commentaires?" do
context "over three different groupe_gestionnaire" do
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, created_at: 12.hours.ago) }
let!(:follow_commentaire_groupe_gestionnaire) { create(:follow_commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, gestionnaire: gestionnaire, sender: administrateur, commentaire_seen_at: Time.zone.now) }
let(:gestionnaire_unread_commentaire_cause_never_seen) { create(:gestionnaire) }
let(:administrateur_unread_commentaire_cause_never_seen) { create(:administrateur) }
let(:administrateur_unread_commentaire_cause_never_seen) { administrateurs(:default_admin) }
let(:groupe_gestionnaire_unread_commentaire_cause_never_seen) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire_unread_commentaire_cause_never_seen]) }
let!(:commentaire_groupe_gestionnaire_unread_commentaire_cause_never_seen) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire_unread_commentaire_cause_never_seen, sender: administrateur_unread_commentaire_cause_never_seen, created_at: 12.hours.ago) }
let(:gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire) { create(:gestionnaire) }
let(:administrateur_unread_commentaire_cause_seen_at_before_last_commentaire) { create(:administrateur) }
let(:administrateur_unread_commentaire_cause_seen_at_before_last_commentaire) { administrateurs(:default_admin) }
let(:groupe_gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire]) }
let!(:commentaire_groupe_gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire, sender: administrateur_unread_commentaire_cause_seen_at_before_last_commentaire, created_at: 12.hours.ago) }
let!(:follow_commentaire_groupe_gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire) { create(:follow_commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire, gestionnaire: gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire, sender: administrateur_unread_commentaire_cause_seen_at_before_last_commentaire, commentaire_seen_at: 1.day.ago) }
@ -110,7 +110,7 @@ describe Gestionnaire, type: :model do
let(:gestionnaire) { create(:gestionnaire) }
let(:gestionnaire_unread_commentaire_cause_never_seen) { create(:gestionnaire) }
let(:gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire, gestionnaire_unread_commentaire_cause_never_seen, gestionnaire_unread_commentaire_cause_seen_at_before_last_commentaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, created_at: 12.hours.ago) }
@ -128,7 +128,7 @@ describe Gestionnaire, type: :model do
describe "#commentaire_seen_at" do
context "when already seen commentaire" do
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, created_at: 12.hours.ago) }
let!(:follow_commentaire_groupe_gestionnaire) { create(:follow_commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, gestionnaire: gestionnaire, sender: administrateur, commentaire_seen_at: Time.zone.now) }
@ -138,7 +138,7 @@ describe Gestionnaire, type: :model do
context "when never seen commentaire" do
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, created_at: 12.hours.ago) }
@ -150,7 +150,7 @@ describe Gestionnaire, type: :model do
context "when already seen commentaire" do
let(:now) { Time.zone.now.beginning_of_minute }
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, created_at: 12.hours.ago) }
let!(:follow_commentaire_groupe_gestionnaire) { create(:follow_commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, gestionnaire: gestionnaire, sender: administrateur, commentaire_seen_at: 12.hours.ago) }
@ -170,7 +170,7 @@ describe Gestionnaire, type: :model do
context "when never seen commentaire" do
let(:now) { Time.zone.now.beginning_of_minute }
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:groupe_gestionnaire) { create(:groupe_gestionnaire, gestionnaires: [gestionnaire]) }
let!(:commentaire_groupe_gestionnaire) { create(:commentaire_groupe_gestionnaire, groupe_gestionnaire: groupe_gestionnaire, sender: administrateur, created_at: 12.hours.ago) }

2
spec/models/groupe_gestionnaire_spec.rb
View file

@ -21,7 +21,7 @@ describe GroupeGestionnaire, type: :model do
describe "#add_administrateur" do
let(:groupe_gestionnaire) { create(:groupe_gestionnaire) }
let(:gestionnaire) { create(:gestionnaire) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
subject { groupe_gestionnaire.add_administrateur(administrateur) }

6
spec/models/instructeur_spec.rb
View file

@ -554,7 +554,7 @@ describe Instructeur, type: :model do
subject { instructeur.can_be_deleted? }
context 'when the instructeur is an administrateur' do
let!(:administrateur) { create(:administrateur) }
let!(:administrateur) { administrateurs(:default_admin) }
let(:instructeur) { administrateur.instructeur }
it { is_expected.to be false }
@ -817,7 +817,7 @@ describe Instructeur, type: :model do
end
context 'when the old instructeur is on on admin list' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before do
administrateur.instructeurs << old_instructeur
@ -830,7 +830,7 @@ describe Instructeur, type: :model do
end
context 'when both are on the same admin list' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before do
administrateur.instructeurs << old_instructeur

2
spec/models/service_spec.rb
View file

@ -1,6 +1,6 @@
describe Service, type: :model do
describe 'validation' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:params) do
{
nom: 'service des jardins',

10
spec/models/user_spec.rb
View file

@ -122,7 +122,7 @@ describe User, type: :model do
end
context 'with an administrateur' do
let(:admins) { [create(:administrateur)] }
let(:admins) { [administrateurs(:default_admin)] }
it do
user = subject
@ -141,7 +141,7 @@ describe User, type: :model do
end
context 'with an existing instructeur' do
let(:old_admins) { [create(:administrateur)] }
let(:old_admins) { [administrateurs(:default_admin)] }
let(:admins) { [create(:administrateur)] }
let!(:instructeur) { create(:instructeur, email: 'i@mail.com', administrateurs: old_admins) }
@ -237,7 +237,7 @@ describe User, type: :model do
describe 'invite_administrateur!' do
let(:super_admin) { create(:super_admin) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:user) { administrateur.user }
let(:mailer_double) { double('mailer', deliver_later: true) }
@ -284,7 +284,7 @@ describe User, type: :model do
describe '#can_be_deleted?' do
let(:user) { create(:user) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:instructeur) { create(:instructeur) }
let(:expert) { create(:expert) }
@ -383,7 +383,7 @@ describe User, type: :model do
it { expect { subject }.not_to raise_error }
it { expect { subject }.to change { FranceConnectInformation.count }.from(2).to(0) }
it { expect { subject }.to change { User.count }.from(1).to(0) }
it { expect { subject }.to change { User.count }.by(-1) }
end
end

2
spec/rails_helper.rb
View file

@ -62,6 +62,8 @@ RSpec.configure do |config|
# instead of true.
config.use_transactional_fixtures = true
config.global_fixtures = :administrateurs, :instructeurs, :users
# RSpec Rails can automatically mix in different behaviours to your tests
# based on their file location, for example enabling you to call `get` and
# `post` in specs under `spec/controllers`.

4
spec/services/administrateur_deletion_service_spec.rb
View file

@ -1,13 +1,13 @@
describe AdministrateurDeletionService do
let(:super_admin) { create(:super_admin) }
let(:admin) { create(:administrateur) }
let(:admin) { administrateurs(:default_admin) }
let(:service) { create(:service, administrateur: admin) }
let(:other_admin) { create(:administrateur) }
let(:procedure) { create(:procedure, service: service, administrateurs: [admin, other_admin]) }
let(:owned_procedure_service) { create(:service, administrateur: admin) }
let(:owned_procedure) { create(:procedure, service: owned_procedure_service, administrateurs: [admin]) }
describe '#call' do
describe '' do
subject { AdministrateurDeletionService.new(super_admin, admin).call }
context 'when admin can be deleted' do

4
spec/services/dossier_search_service_spec.rb
View file

@ -6,8 +6,8 @@ describe DossierSearchService do
described_class.matching_dossiers(instructeur_1.dossiers, terms)
end
let(:administrateur_1) { create(:administrateur) }
let(:administrateur_2) { create(:administrateur) }
let(:administrateur_1) { administrateurs(:default_admin) }
let(:administrateur_2) { administrateurs(:default_admin) }
let(:instructeur_1) { create(:instructeur, administrateurs: [administrateur_1]) }
let(:instructeur_2) { create(:instructeur, administrateurs: [administrateur_2]) }

2
spec/services/expired/expired_dossiers_deletion_service_spec.rb
View file

@ -4,7 +4,7 @@ describe Expired::DossiersDeletionService do
let(:user) { create(:user) }
let(:procedure_opts) { {} }
let(:procedure) { create(:procedure, :published, procedure_opts) }
let(:procedure_2) { create(:procedure, :published, procedure_opts) }
let(:procedure_2) { create(:procedure, :published, :new_administrateur, procedure_opts) }
let(:reference_date) { Date.parse("March 8") }
let(:service) { Expired::DossiersDeletionService.new }
describe '#process_expired_dossiers_brouillon' do

6
spec/services/expired/expired_users_deletion_service_spec.rb
View file

@ -139,12 +139,12 @@ describe Expired::UsersDeletionService do
end
context 'when user is expired and has an admin' do
let(:user) { create(:user, administrateur: create(:administrateur), last_sign_in_at: last_signed_in_expired) }
let(:user) { create(:user, administrateur: administrateurs(:default_admin), last_sign_in_at: last_signed_in_expired) }
it { is_expected.not_to include(user) }
end
context 'when user is expired but have a dossier' do
let(:user) { create(:user, administrateur: create(:administrateur), last_sign_in_at: last_signed_in_expired) }
let(:user) { users(:default_user_admin).tap { _1.update(last_sign_in_at: last_signed_in_expired) } }
let(:dossier) { create(:dossier, :brouillon, user:, created_at: last_signed_in_expired) }
it { is_expected.not_to include(user) }
end
@ -210,7 +210,7 @@ describe Expired::UsersDeletionService do
context 'when user is expired and has an admin' do
let(:dossier) { create(:dossier, user:, created_at: last_signed_in_expired) }
let(:user) { create(:user, administrateur: create(:administrateur), last_sign_in_at: last_signed_in_expired) }
let(:user) { users(:default_user_admin).tap { _1.update(last_sign_in_at: last_signed_in_expired) } }
it { is_expected.not_to include(user) }
end
end

2
spec/services/procedure_archive_service_spec.rb
View file

@ -1,7 +1,7 @@
describe ProcedureArchiveService do
let(:procedure) { create(:procedure, :published, administrateurs: [administrateur]) }
let(:instructeur) { create(:instructeur) }
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:service) { ProcedureArchiveService.new(procedure) }
let(:year) { 2020 }
let(:month) { 3 }

6
spec/system/administrateurs/procedure_administrateurs_spec.rb
View file

@ -3,11 +3,11 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'Administrateurs can manage administrateurs', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let!(:procedure) { create(:procedure) }
let!(:administrateurs_procedure) { create(:administrateurs_procedure, administrateur: administrateur, procedure: procedure, manager: manager) }
let(:administrateur) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure) }
let(:manager) { false }
before do
procedure.administrateurs_procedures.update_all(manager:)
login_as administrateur.user, scope: :user
end

2
spec/system/administrateurs/procedure_archive_and_export_spec.rb
View file

@ -3,7 +3,7 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'Creating a new procedure', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:procedure) do
create(:procedure, :with_service, :with_instructeur,
aasm_state: :publiee,

2
spec/system/administrateurs/procedure_attestation_template_spec.rb
View file

@ -3,7 +3,7 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'As an administrateur, I want to manage the procedure’s attestation', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:procedure) do
create(:procedure, :with_service, :with_instructeur, :with_zone,
aasm_state: :brouillon,

2
spec/system/administrateurs/procedure_cloning_spec.rb
View file

@ -3,7 +3,7 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'As an administrateur I wanna clone a procedure', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before do
create(:procedure, :with_service, :with_instructeur, :with_zone,

2
spec/system/administrateurs/procedure_closing_spec.rb
View file

@ -3,7 +3,7 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'Closing a procedure', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let!(:procedure) do
create(:procedure_with_dossiers,
:published,

2
spec/system/administrateurs/procedure_creation_spec.rb
View file

@ -3,7 +3,7 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'Creating a new procedure', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before do
login_as administrateur.user, scope: :user

6
spec/system/administrateurs/procedure_groupe_instructeur_spec.rb
View file

@ -3,11 +3,11 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'Manage procedure instructeurs', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let!(:procedure) { create(:procedure) }
let!(:administrateurs_procedure) { create(:administrateurs_procedure, administrateur: administrateur, procedure: procedure, manager: manager) }
let(:administrateur) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure) }
let(:manager) { false }
before do
procedure.administrateurs_procedures.update_all(manager:)
login_as administrateur.user, scope: :user
end

2
spec/system/administrateurs/procedure_locked_spec.rb
View file

@ -1,5 +1,5 @@
describe 'procedure locked' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before do
login_as administrateur.user, scope: :user

2
spec/system/administrateurs/procedure_publish_spec.rb
View file

@ -3,7 +3,7 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'Publishing a procedure', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:other_administrateur) { create(:administrateur) }
let(:instructeurs) { [administrateur.user.instructeur] }

2
spec/system/administrateurs/procedure_update_spec.rb
View file

@ -3,7 +3,7 @@ require 'system/administrateurs/procedure_spec_helper'
describe 'Administrateurs can edit procedures', js: true do
include ProcedureSpecHelper
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let!(:procedure) do
create(:procedure_with_dossiers,
:published,

2
spec/system/api_particulier/api_particulier_spec.rb
View file

@ -1,5 +1,5 @@
describe 'fetch API Particulier Data', js: true do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:expected_token) { 'd7e9c9f4c3ca00caadde31f50fd4521a' }

2
spec/system/instructeurs/batch_operation_spec.rb
View file

@ -4,7 +4,7 @@ describe 'BatchOperation a dossier:', js: true do
let(:password) { 'demarches-simplifiees' }
let(:instructeur) { create(:instructeur, password: password) }
let(:procedure) { create(:simple_procedure, :published, instructeurs: [instructeur], administrateurs: [create(:administrateur)]) }
let(:procedure) { create(:simple_procedure, :published, instructeurs: [instructeur], administrateurs: [administrateurs(:default_admin)]) }
context 'with an instructeur' do
scenario 'create a BatchOperation' do

2
spec/system/patron_spec.rb
View file

@ -1,5 +1,5 @@
describe 'Accessing the /patron page:' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
before { sign_in administrateur.user }
scenario 'I can display a page with all form fields and UI elements' do

2
spec/system/users/managing_password_spec.rb
View file

@ -29,7 +29,7 @@ describe 'Managing password:', js: true do
end
context 'for admins' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:user) { administrateur.user }
let(:weak_password) { '12345678' }
let(:strong_password) { 'a new, long, and complicated password!' }

2
spec/system/users/sign_out_spec.rb
View file

@ -1,6 +1,6 @@
describe 'Sign out' do
context 'when a user is logged in' do
let(:user) { create(:administrateur).user }
let(:user) { administrateurs(:default_admin).user }
before { login_as user, scope: :user }

2
spec/views/administrateurs/procedures/zones.html.haml_spec.rb
View file

@ -1,5 +1,5 @@
describe 'administrateurs/procedures/zones' do
let(:administrateur) { create(:administrateur) }
let(:administrateur) { administrateurs(:default_admin) }
let(:procedure) { create(:procedure) }
let(:populate_zones_task) { Rake::Task['after_party:populate_zones_with_tchap_hs'] }