<%= link_to t('candidate.grouping_legal_types.back'),
- application_mode_candidate_market_application_path(@market_application.identifier, readonly: true),
+ previous_wizard_path(readonly: true),
class: "fr-btn fr-btn--secondary fr-icon-arrow-left-line fr-btn--icon-left" %>
<%= form.button t('candidate.grouping_legal_types.continue'),
type: "submit",
diff --git a/app/views/candidate/grouping_wizard/lot_selection_mode.html.erb b/app/views/candidate/grouping_wizard/lot_selection_mode.html.erb
new file mode 100644
index 000000000..1c79e658c
--- /dev/null
+++ b/app/views/candidate/grouping_wizard/lot_selection_mode.html.erb
@@ -0,0 +1,120 @@
+<% content_for :title, t('candidate.lot_selection_modes.title') %>
+
+
+
<%= t('candidate.lot_selection_modes.title') %>
+
+ <%= t(@presenter.requires_solo_and_groupement? ? 'candidate.lot_selection_modes.subtitle_mixte' : 'candidate.lot_selection_modes.subtitle_groupement') %>
+
+
+
+
+
+
+
+
<%= t('candidate.lot_selection_modes.rc_notice_title') %>
+
+ <%= t('candidate.lot_selection_modes.rc_notice_body') %>
+ <%= link_to t('candidate.lot_selection_modes.rc_notice_link'), '#',
+ class: "fr-link fr-link--icon-right fr-icon-external-link-line",
+ target: "_blank", rel: "noopener" %>
+
+
+
+
+ <% if @errors.present? %>
+
+
+ <% @errors.each do |_attribute, messages| %>
+ <% Array(messages).each do |message| %>
+ - <%= message %>
+ <% end %>
+ <% end %>
+
+
+ <% end %>
+
+ <%= form_with url: wizard_path, method: :patch do %>
+ <% @presenter.lots_by_type_sorted.each do |market_type, type_lots| %>
+
+
+
+
+
+
+ | <%= t('candidate.lot_selection_modes.lot_column_header') %> |
+ <%= t('candidate.lot_selection_modes.name_column_header') %> |
+ |
+
+
+
+ <% type_lots.each do |lot| %>
+
+ | <%= t('candidate.lot_selection_modes.lot_number', number: lot.position) %> |
+ <%= lot.name %> |
+
+
+ <% %w[solo groupement none].each do |mode| %>
+ <% next if mode == 'solo' && !@presenter.requires_solo_and_groupement? %>
+
+ <%= radio_button_tag "lot_modes[#{lot.id}]", mode, @presenter.mode_for(lot) == mode,
+ id: "lot_mode_#{lot.id}_#{mode}",
+ class: "lot-mode-choice__input",
+ data: { lot_selection_mode_target: "radio", action: "change->lot-selection-mode#recompute" } %>
+ <%= label_tag "lot_mode_#{lot.id}_#{mode}", t("candidate.lot_selection_modes.#{mode}"),
+ class: "lot-mode-choice__label" %>
+
+ <% end %>
+
+ |
+
+ <% end %>
+
+
+
+ <% end %>
+
+ <% if @presenter.requires_solo_and_groupement? %>
+
+
+ <%= t('candidate.lot_selection_modes.banner_text') %>
+
+ <% end %>
+
+
+ <%= link_to t('candidate.lot_selection_modes.back'),
+ previous_wizard_path(readonly: true),
+ class: "fr-btn fr-btn--secondary fr-icon-arrow-left-line fr-btn--icon-left" %>
+ <%= button_tag t('candidate.lot_selection_modes.continue'),
+ type: "submit",
+ class: "fr-btn fr-icon-arrow-right-line fr-btn--icon-right",
+ data: { lot_selection_mode_target: "submitButton" } %>
+
+ <% end %>
+
diff --git a/app/views/grouping_invitation_mailer/invitation.html.erb b/app/views/grouping_invitation_mailer/invitation.html.erb
new file mode 100644
index 000000000..057e32fc1
--- /dev/null
+++ b/app/views/grouping_invitation_mailer/invitation.html.erb
@@ -0,0 +1 @@
+<%= render GroupingInvitationEmailComponent.new(url: @url, market_name: @market_name) %>
diff --git a/app/views/grouping_invitation_mailer/invitation.text.erb b/app/views/grouping_invitation_mailer/invitation.text.erb
new file mode 100644
index 000000000..9ba2f6133
--- /dev/null
+++ b/app/views/grouping_invitation_mailer/invitation.text.erb
@@ -0,0 +1,10 @@
+<%= t('grouping_invitation_mailer.invitation.greeting') %>
+
+<%= t('grouping_invitation_mailer.invitation.intro') %>
+<%= @market_name %>
+
+<%= t('grouping_invitation_mailer.invitation.cta_intro') %>
+<%= @url %>
+
+<%= t('auth_mailer.magic_link.footer.copyright') %>
+<%= t('auth_mailer.magic_link.footer.contact') %>
diff --git a/config/locales/fr.yml b/config/locales/fr.yml
index f1bc888d8..99c4a0b9d 100644
--- a/config/locales/fr.yml
+++ b/config/locales/fr.yml
@@ -33,6 +33,15 @@ fr:
market_intro: "Vous pouvez accéder au formulaire de candidature pour le marché :"
cta_intro: "Cliquez sur le bouton ci-dessous pour vous reconnecter et continuer :"
cta: Poursuivre ma candidature
+
+ grouping_invitation_mailer:
+ invitation:
+ subject: "Vous avez été invité à candidater en groupement"
+ greeting: Bonjour,
+ intro: "Vous avez été invité à rejoindre un groupement en tant que co-traitant pour candidater au marché :"
+ cta_intro: "Cliquez sur le bouton ci-dessous pour rejoindre le groupement :"
+ cta: Rejoindre le groupement
+
source_types:
authentic_source:
label: Récupéré automatiquement
@@ -594,6 +603,9 @@ fr:
mixte:
label: "Candidater seul et en groupement"
hint: "Je réponds seul sur certains lots et je suis mandataire du groupement sur d'autres"
+ grouping_invitations:
+ title: "Invitation au groupement"
+ pending: "Votre invitation est en cours de traitement."
grouping_legal_types:
title: "Le type de groupement"
step_current: "Étape 1 sur 3"
@@ -613,6 +625,41 @@ fr:
conjoint_mandataire_solidaire:
label: "Conjoint + mandataire solidaire"
hint: "Chaque membre est responsable de sa propre part du marché. En revanche, le mandataire est solidaire des autres membres : si l'un d'eux est défaillant, seul le mandataire devra répondre de ses obligations vis-à-vis de l'acheteur."
+ grouping_compositions:
+ title: "Les membres du groupement"
+ step_current: "Étape 2 sur 3"
+ step_next: "Étape suivante :"
+ step_next_label: "Confirmation de la composition"
+ intro: "Ajoutez les co-traitants qui candidateront avec vous. Les invitations ne partiront qu'après confirmation de la composition."
+ table_company: "Entreprise"
+ table_email: "Email"
+ table_role: "Rôle"
+ table_status: "Statut des invitations"
+ company_unknown: "Entreprise"
+ role_mandataire: "MANDATAIRE"
+ role_co_traitant: "CO-TRAITANT"
+ status_not_sent: "NON ENVOYÉ"
+ status_sent: "ENVOYÉ"
+ no_co_traitant_line1: "Aucun co-traitant dans le groupement pour l'instant."
+ no_co_traitant_line2: "Ajoutez au moins un co-traitant ci-dessous pour pouvoir continuer."
+ add_member_title: "Ajouter un co-traitant"
+ siret_label: "Numéro de SIRET"
+ siret_hint: "Consultez"
+ siret_hint_link: "l'annuaire des entreprises"
+ email_label: "Email du contact"
+ email_hint: "Destinataire de l'invitation"
+ add_button: "Ajouter au groupement"
+ remove_button: "Retirer"
+ back: "Précédent"
+ continue: "Continuer"
+ success: "Le groupement a été créé et les invitations ont été envoyées"
+ confirm:
+ title: "Récapitulatif du groupement"
+ step_current: "Étape 3 sur 3"
+ step_next_label: "Confirmation de la composition"
+ legal_type_label: "Type de groupement :"
+ modify: "Modifier la composition"
+ submit: "Confirmer et envoyer les invitations"
lot_selection:
title: "Sélectionnez un ou plusieurs lot(s)"
subtitle: "Sélectionnez le ou les lots pour lequel/lesquels vous souhaitez soumettre une candidature."
@@ -654,15 +701,42 @@ fr:
how_it_works_title: "Comment ça fonctionne"
how_it_works_step_1: "Complétez le formulaire de candidature"
how_it_works_step_2: "Soumettez votre candidature (vous pouvez soumettre même si toutes les informations n'ont pas été complétées)"
+ lot_selection_modes:
+ title: "Sélectionnez les lots pour la candidature"
+ subtitle_mixte: "Sélectionnez les lots auxquels vous allez candidater seul ou en groupement."
+ subtitle_groupement: "Sélectionnez les lots auxquels le groupement va candidater."
+ rc_notice_title: "En cas de doute, consultez le règlement de consultation"
+ rc_notice_body: "Votre acheteur a peut-être indiqué des règles concernant la gestion des lots dans le règlement de consultation, consultez le"
+ rc_notice_link: "via ce lien"
+ group_title_prefix: "Pour les lots de type"
+ apply_to_typology: "Appliquer à toute la typologie :"
+ apply_to_typology_placeholder: "Choisissez une option"
+ solo: "Seul"
+ groupement: "En groupement"
+ none: "Ne pas répondre"
+ lot_column_header: "Lot"
+ name_column_header: "Nom du lot"
+ lot_number: "Lot %{number}"
+ banner_text: "Vous devez sélectionner au moins un lot \"Seul\" et un lot \"En groupement\" pour continuer."
+ back: "Précédent"
+ continue: "Continuer"
validations:
siret_blank: "Veuillez renseigner votre numéro de SIRET"
siret_invalid: "Le numéro de SIRET saisi est invalide"
+ siret_same_as_mandataire: "Ce numéro de SIRET est celui de votre entreprise, vous faites déjà partie du groupement"
+ siret_already_added: "Ce numéro de SIRET a déjà été ajouté au groupement"
email_blank: "Veuillez renseigner votre adresse email"
email_invalid: "L'adresse email doit avoir un format valide (exemple@domaine.com)"
already_mandataire: "Vous êtes déjà mandataire d'un groupement sur ce marché"
application_mode_invalid: "Le mode de candidature sélectionné n'est pas valide"
grouping_not_found: "Aucun groupement trouvé pour cette candidature"
legal_type_invalid: "Le type de groupement sélectionné n'est pas valide"
+ grouping_member_not_found: "Ce co-traitant n'a pas été trouvé dans le groupement"
+ grouping_member_already_invited: "Ce co-traitant a déjà reçu son invitation, il ne peut plus être retiré"
+ no_co_traitant: "Veuillez ajouter au moins un co-traitant avant de continuer"
+ lot_ids_invalid: "Un ou plusieurs lots sélectionnés n'appartiennent pas à ce marché"
+ lot_selection_mode_incomplete: "Vous devez sélectionner au moins un lot \"Seul\" et un lot \"En groupement\" pour continuer."
+ groupement_application_not_found: "Aucune candidature en groupement trouvée"
request_magic_link:
no_application_found: "Aucune candidature trouvée pour ce numéro SIRET"
no_market_context: "Veuillez accéder à Passe Marché depuis votre plateforme de marchés publics"
@@ -1414,6 +1488,7 @@ fr:
messages:
record_invalid: "La validation a échoué : %{errors}"
cannot_be_alone: "ne peut pas être seul"
+ same_as_mandataire: "correspond au SIRET du mandataire, vous faites déjà partie du groupement"
inclusion: "n'est pas inclus dans la liste des valeurs autorisées"
invalid: "n'est pas valide"
blank: "ne peut pas être vide"
diff --git a/config/routes.rb b/config/routes.rb
index 2a72b6d6d..74a44f89c 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -77,6 +77,7 @@
namespace :candidate do
get 'dashboard', to: 'dashboards#index', as: :dashboard
+ get 'grouping_invitations/:token', to: 'grouping_invitations#show', as: :grouping_invitation
resource :sessions, only: %i[new create destroy] do
get :verify
@@ -86,10 +87,10 @@
resources :market_applications, param: :identifier, only: [:destroy] do
member do
get 'deadline_passed', to: 'deadline_passed#show', as: :deadline_passed
- get 'application_mode', to: 'application_modes#show', as: :application_mode
- patch 'application_mode', to: 'application_modes#update'
- get 'grouping_legal_type', to: 'grouping_legal_types#show', as: :grouping_legal_type
- patch 'grouping_legal_type', to: 'grouping_legal_types#update'
+ get 'grouping_wizard/:id', to: 'grouping_wizard#show', as: :grouping_wizard_step
+ patch 'grouping_wizard/:id', to: 'grouping_wizard#update'
+ post 'grouping_wizard/members', to: 'grouping_wizard#create_member', as: :grouping_wizard_members
+ delete 'grouping_wizard/members/:id', to: 'grouping_wizard#destroy_member', as: :grouping_wizard_member
get 'company_identification', to: 'company_identifications#show', as: :company_identification
patch 'company_identification', to: 'company_identifications#update'
get 'lots', to: 'lot_selections#show', as: :lot_selection
diff --git a/db/migrate/20260804154855_add_company_name_to_grouping_members.rb b/db/migrate/20260804154855_add_company_name_to_grouping_members.rb
new file mode 100644
index 000000000..044081194
--- /dev/null
+++ b/db/migrate/20260804154855_add_company_name_to_grouping_members.rb
@@ -0,0 +1,5 @@
+class AddCompanyNameToGroupingMembers < ActiveRecord::Migration[8.1]
+ def change
+ add_column :grouping_members, :company_name, :string
+ end
+end
diff --git a/db/queue_schema.rb b/db/queue_schema.rb
index ef120376b..e739cf104 100644
--- a/db/queue_schema.rb
+++ b/db/queue_schema.rb
@@ -10,7 +10,7 @@
#
# It's strongly recommended that you check this file into your version control system.
-ActiveRecord::Schema[8.1].define(version: 2026_07_29_100623) do
+ActiveRecord::Schema[8.1].define(version: 2026_08_04_154855) do
# These are extensions that must be enabled in order to support this database
enable_extension "pg_catalog.plpgsql"
@@ -84,6 +84,7 @@
end
create_table "grouping_members", force: :cascade do |t|
+ t.string "company_name"
t.datetime "created_at", null: false
t.string "email"
t.bigint "grouping_id", null: false
diff --git a/db/schema.rb b/db/schema.rb
index ef120376b..e739cf104 100644
--- a/db/schema.rb
+++ b/db/schema.rb
@@ -10,7 +10,7 @@
#
# It's strongly recommended that you check this file into your version control system.
-ActiveRecord::Schema[8.1].define(version: 2026_07_29_100623) do
+ActiveRecord::Schema[8.1].define(version: 2026_08_04_154855) do
# These are extensions that must be enabled in order to support this database
enable_extension "pg_catalog.plpgsql"
@@ -84,6 +84,7 @@
end
create_table "grouping_members", force: :cascade do |t|
+ t.string "company_name"
t.datetime "created_at", null: false
t.string "email"
t.bigint "grouping_id", null: false
diff --git a/features/candidacy_mode_choice.feature b/features/candidacy_mode_choice.feature
index fac695dbe..67cb0197d 100644
--- a/features/candidacy_mode_choice.feature
+++ b/features/candidacy_mode_choice.feature
@@ -45,6 +45,15 @@ Feature: Candidate chooses their candidacy mode
And my application mode should be "solo"
And a second market application should exist with mode "groupement"
+ @javascript
+ Scenario: Candidate reconnects from the groupement funnel after choosing mixte
+ When I visit the magic link
+ And I choose the candidacy mode "mixte"
+ Then I should land on the grouping legal type step of the groupement application
+ When I request a new magic link for the groupement application
+ And I click the link from the latest email
+ Then I should land on the grouping legal type step of the groupement application
+
Scenario: The choice screen is never shown again once a mode is chosen
Given the candidate application already has the mode "solo"
When I visit the magic link
diff --git a/features/grouping_composition.feature b/features/grouping_composition.feature
new file mode 100644
index 000000000..00b16e6cc
--- /dev/null
+++ b/features/grouping_composition.feature
@@ -0,0 +1,104 @@
+Feature: Mandataire composes the grouping and sends invitations
+
+ As a mandataire candidate
+ I want to add my co-traitants (SIRET + email) and confirm the composition
+ So that invitations are sent to them
+
+ Background:
+ Given the groupement feature flag is enabled
+ And a public market exists
+ And a candidate application exists for SIRET "73282932000074"
+ And a candidate "candidat@example.com" has a valid magic link token
+
+ @javascript
+ Scenario: Mandataire sees the grouping composition screen
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ Then I should see "Les membres du groupement"
+ And I should see "MANDATAIRE" in the members table
+
+ @javascript
+ Scenario: Add button is disabled until both fields are filled
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ Then the "Ajouter au groupement" button should be disabled
+
+ @javascript
+ Scenario: Continue link is disabled until at least one co-traitant is added
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ Then the "Continuer" link should be disabled
+
+ @javascript
+ Scenario: Mandataire adds a valid co-traitant
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ And I add a co-traitant with SIRET "80245139600021" and email "contact@menuiseries-loire.fr"
+ Then I should see "80245139600021" in the members table
+ And the co-traitant "80245139600021" status should be "NON ENVOYÉ"
+ And the "Continuer" link should be enabled
+
+ @javascript
+ Scenario: Mandataire cannot add a co-traitant with an invalid SIRET
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ And I add a co-traitant with SIRET "0000000000" and email "contact@menuiseries-loire.fr"
+ Then I should see an error about the SIRET
+ And the email field should still contain "contact@menuiseries-loire.fr"
+
+ @javascript
+ Scenario: Mandataire cannot add a co-traitant with their own SIRET
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ And I add a co-traitant with SIRET "73282932000074" and email "contact@menuiseries-loire.fr"
+ Then I should see an error about the SIRET
+
+ @javascript
+ Scenario: Mandataire cannot add the same SIRET twice
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ And I add a co-traitant with SIRET "80245139600021" and email "contact@menuiseries-loire.fr"
+ And I add a co-traitant with SIRET "80245139600021" and email "other@menuiseries-loire.fr"
+ Then I should see an error about the SIRET
+
+ @javascript
+ Scenario: Mandataire cannot add a co-traitant with an invalid email
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ And I add a co-traitant with SIRET "80245139600021" and email "not-an-email"
+ Then I should see an error about the email
+ And the SIRET field should still contain "80245139600021"
+
+ @javascript
+ Scenario: Mandataire removes a co-traitant before confirmation
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ And I add a co-traitant with SIRET "80245139600021" and email "contact@menuiseries-loire.fr"
+ And I remove the co-traitant "80245139600021"
+ Then I should not see "80245139600021" in the members table
+
+ @javascript
+ Scenario: Mandataire confirms the composition and invitations are sent
+ When I visit the magic link
+ And I choose the candidacy mode "groupement"
+ And I choose the grouping legal type "conjoint_mandataire_solidaire"
+ And I add a co-traitant with SIRET "80245139600021" and email "contact@menuiseries-loire.fr"
+ And I click on "Continuer"
+ Then I should see "Récapitulatif du groupement"
+ When I click on "Confirmer et envoyer les invitations"
+ Then I should see "Le groupement a été créé et les invitations ont été envoyées"
+ And an invitation email should have been sent for the co-traitant "80245139600021"
+
+ Scenario: A candidate who is not mandataire of a grouping cannot access the composition screen
+ Given I am authenticated for my application
+ When I visit the grouping composition step directly
+ Then I should be on the candidacy mode choice step
diff --git a/features/grouping_legal_type.feature b/features/grouping_legal_type.feature
index 98102da2f..972cfb8f9 100644
--- a/features/grouping_legal_type.feature
+++ b/features/grouping_legal_type.feature
@@ -30,7 +30,7 @@ Feature: Mandataire defines the grouping legal type
When I visit the magic link
And I choose the candidacy mode "groupement"
And I choose the grouping legal type "conjoint_mandataire_solidaire"
- Then I should be on the company identification step
+ Then I should be on the grouping composition step
And the grouping legal type should be "conjoint_mandataire_solidaire"
Scenario: A candidate who is not mandataire of a grouping cannot access the screen
@@ -42,7 +42,8 @@ Feature: Mandataire defines the grouping legal type
Scenario: Candidate logs in again before choosing the legal type
When I visit the magic link
And I choose the candidacy mode "groupement"
- And I visit the magic link
+ Then I should see "Le type de groupement"
+ When I visit the magic link
Then I should be on the grouping legal type step
@javascript
diff --git a/features/lot_selection_mode.feature b/features/lot_selection_mode.feature
new file mode 100644
index 000000000..e75b3cc83
--- /dev/null
+++ b/features/lot_selection_mode.feature
@@ -0,0 +1,104 @@
+Feature: Mandataire selects lots and their response mode
+
+ As a mandataire candidate
+ I want to choose, for each lot, whether I apply alone, as part of the groupement, or not at all
+ So that mixed scenarios are covered
+
+ Background:
+ Given the groupement feature flag is enabled
+ And a multi-type public market with lots exists
+ And a candidate starts a new application for the multi-type market
+
+ @javascript
+ Scenario: Mandataire in mixte mode sees the three options per lot
+ When I choose the candidacy mode "mixte"
+ Then I should see "Sélectionnez les lots pour la candidature"
+ And each lot should offer the options "Seul", "En groupement" and "Ne pas répondre"
+
+ @javascript
+ Scenario: Mandataire in groupement-only mode sees only two options per lot
+ When I choose the candidacy mode "groupement"
+ Then each lot should offer the options "En groupement" and "Ne pas répondre"
+ And the lot option "Seul" should not be visible
+
+ @javascript
+ Scenario: All lots are pre-selected on En groupement by default
+ When I choose the candidacy mode "groupement"
+ Then every lot should be set to "En groupement"
+
+ @javascript
+ Scenario: Continue button is disabled until at least one solo and one groupement lot are set in mixte mode
+ When I choose the candidacy mode "mixte"
+ And I set lot "Lot 1 - Gros œuvre" to "solo"
+ And I set lot "Lot 2 - Charpente" to "solo"
+ And I set lot "Lot 3 - Prestations SI" to "solo"
+ Then the "Continuer" button should be disabled
+ When I set lot "Lot 3 - Prestations SI" to "groupement"
+ Then the "Continuer" button should be enabled
+
+ @javascript
+ Scenario: Continue button is disabled until at least one lot is set to groupement in groupement-only mode
+ When I choose the candidacy mode "groupement"
+ And I set lot "Lot 1 - Gros œuvre" to "none"
+ And I set lot "Lot 2 - Charpente" to "none"
+ And I set lot "Lot 3 - Prestations SI" to "none"
+ Then the "Continuer" button should be disabled
+ When I set lot "Lot 3 - Prestations SI" to "groupement"
+ Then the "Continuer" button should be enabled
+
+ @javascript
+ Scenario: The mixed mode banner is shown in mixte mode
+ When I choose the candidacy mode "mixte"
+ Then I should see "Vous devez sélectionner au moins un lot"
+
+ @javascript
+ Scenario: The mixed mode banner is not shown in groupement-only mode
+ When I choose the candidacy mode "groupement"
+ Then I should not see "Vous devez sélectionner au moins un lot"
+
+ @javascript
+ Scenario: Lots are grouped by typology
+ When I choose the candidacy mode "groupement"
+ Then I should see a section for the lot typology "works"
+ And I should see a section for the lot typology "services"
+
+ @javascript
+ Scenario: Applying a mode to a whole typology updates every lot of that section
+ When I choose the candidacy mode "groupement"
+ And I apply "Ne pas répondre" to the typology "works"
+ Then every lot of the typology "works" should be set to "Ne pas répondre"
+ And every lot of the typology "services" should be set to "En groupement"
+
+ @javascript
+ Scenario: A lot can be adjusted individually after a bulk action without affecting the others
+ When I choose the candidacy mode "groupement"
+ And I apply "Ne pas répondre" to the typology "works"
+ And I set lot "Lot 1 - Gros œuvre" to "groupement"
+ Then lot "Lot 1 - Gros œuvre" should be set to "En groupement"
+ And lot "Lot 2 - Charpente" should be set to "Ne pas répondre"
+
+ @javascript
+ Scenario: Mandataire submits the lot selection and reaches the grouping legal type step
+ When I choose the candidacy mode "groupement"
+ And I set lot "Lot 1 - Gros œuvre" to "groupement"
+ And I click on "Continuer"
+ Then I should be on the grouping legal type step
+
+ @javascript
+ Scenario: Mandataire goes back from the grouping legal type step to review the lot selection
+ When I choose the candidacy mode "groupement"
+ And I set lot "Lot 1 - Gros œuvre" to "groupement"
+ And I click on "Continuer"
+ And I should be on the grouping legal type step
+ And I click on "Précédent"
+ Then I should see "Sélectionnez les lots pour la candidature"
+ And lot "Lot 1 - Gros œuvre" should be set to "En groupement"
+
+ @javascript
+ Scenario: Mandataire in mixte mode still reaches lot selection when revisiting the read-only candidacy mode from the solo side
+ When I choose the candidacy mode "mixte"
+ Then I should see "Sélectionnez les lots pour la candidature"
+ When I visit the read-only candidacy mode step of the solo application
+ Then I should see "Comment souhaitez-vous candidater ?"
+ When I click on "Continuer"
+ Then I should see "Sélectionnez les lots pour la candidature"
diff --git a/features/step_definitions/candidacy_mode_steps.rb b/features/step_definitions/candidacy_mode_steps.rb
index b51544200..d62cdf265 100644
--- a/features/step_definitions/candidacy_mode_steps.rb
+++ b/features/step_definitions/candidacy_mode_steps.rb
@@ -32,14 +32,21 @@
Then('I should be on the grouping legal type step') do
expect(page).to have_current_path(
- grouping_legal_type_candidate_market_application_path(@market_application.identifier),
+ grouping_wizard_step_candidate_market_application_path(@market_application.identifier, :grouping_legal_type),
+ ignore_query: true
+ )
+end
+
+Then('I should be on the grouping composition step') do
+ expect(page).to have_current_path(
+ grouping_wizard_step_candidate_market_application_path(@market_application.identifier, :grouping_composition),
ignore_query: true
)
end
Then('I should be on the candidacy mode choice step') do
expect(page).to have_current_path(
- application_mode_candidate_market_application_path(@market_application.identifier),
+ grouping_wizard_step_candidate_market_application_path(@market_application.identifier, :application_mode),
ignore_query: true
)
end
@@ -52,9 +59,9 @@
end
Then('I should land on the grouping legal type step of the groupement application') do
- expect(page).to have_current_path(%r{/candidate/market_applications/.+/grouping_legal_type})
+ expect(page).to have_current_path(%r{/candidate/market_applications/.+/grouping_wizard/grouping_legal_type})
- landed_identifier = page.current_path[%r{/candidate/market_applications/([^/]+)/grouping_legal_type}, 1]
+ landed_identifier = page.current_path[%r{/candidate/market_applications/([^/]+)/grouping_wizard/grouping_legal_type}, 1]
expect(landed_identifier).not_to eq(@market_application.identifier)
@groupement_market_application = MarketApplication.find_by!(identifier: landed_identifier)
diff --git a/features/step_definitions/candidate_authentication_steps.rb b/features/step_definitions/candidate_authentication_steps.rb
index 4f19f21b5..51ef62db2 100644
--- a/features/step_definitions/candidate_authentication_steps.rb
+++ b/features/step_definitions/candidate_authentication_steps.rb
@@ -47,6 +47,19 @@
)
end
+When('I request a new magic link for the groupement application') do
+ visit new_candidate_sessions_path(market_application_id: @groupement_market_application.identifier)
+ fill_in I18n.t('candidate.sessions.new.email_label'), with: @user.email
+ find_button(I18n.t('candidate.sessions.new.submit'), disabled: false).click
+ expect(page).to have_current_path(sent_candidate_sessions_path, ignore_query: true)
+end
+
+When('I click the link from the latest email') do
+ mail = ActionMailer::Base.deliveries.last
+ url = mail.text_part.body.decoded[%r{https?://\S+}]
+ visit URI(url).request_uri
+end
+
Then('I should see the authentication form') do
expect(page).to have_selector('form[action*="candidate/sessions"]')
end
diff --git a/features/step_definitions/grouping_composition_steps.rb b/features/step_definitions/grouping_composition_steps.rb
new file mode 100644
index 000000000..57d08ae08
--- /dev/null
+++ b/features/step_definitions/grouping_composition_steps.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+When('I add a co-traitant with SIRET {string} and email {string}') do |siret, email|
+ fill_in I18n.t('candidate.grouping_compositions.siret_label'), with: siret
+ fill_in I18n.t('candidate.grouping_compositions.email_label'), with: email
+ find_button(I18n.t('candidate.grouping_compositions.add_button'), disabled: false).click
+
+ within('#grouping_members_table') { page.has_content?(siret) } || page.has_css?('.fr-error-text')
+end
+
+When('I remove the co-traitant {string}') do |siret|
+ member = GroupingMember.find_by!(siret:)
+ within("form[action='#{grouping_wizard_member_candidate_market_application_path(@market_application.identifier, member)}']") do
+ click_button I18n.t('candidate.grouping_compositions.remove_button')
+ end
+end
+
+When('I visit the grouping composition step directly') do
+ visit grouping_wizard_step_candidate_market_application_path(@market_application.identifier, :grouping_composition)
+end
+
+Then('I should see {string} in the members table') do |text|
+ within('#grouping_members_table') { expect(page).to have_content(text) }
+end
+
+Then('I should not see {string} in the members table') do |text|
+ within('#grouping_members_table') { expect(page).not_to have_content(text) }
+end
+
+Then('the co-traitant {string} status should be {string}') do |siret, status|
+ member_row = find('#grouping_members_table').find('tr', text: siret)
+ expect(member_row).to have_content(status)
+end
+
+Then('I should see an error about the SIRET') do
+ expect(page).to have_css('.fr-error-text')
+end
+
+Then('I should see an error about the email') do
+ expect(page).to have_css('.fr-error-text')
+end
+
+Then('the SIRET field should still contain {string}') do |siret|
+ expect(page).to have_field(I18n.t('candidate.grouping_compositions.siret_label'), with: siret)
+end
+
+Then('the email field should still contain {string}') do |email|
+ expect(page).to have_field(I18n.t('candidate.grouping_compositions.email_label'), with: email)
+end
+
+Then('the {string} link should be disabled') do |label|
+ expect(page).to have_css("a[aria-disabled='true']", text: label)
+end
+
+Then('the {string} link should be enabled') do |label|
+ expect(page).to have_css("a[aria-disabled='false']", text: label)
+end
+
+Then('an invitation email should have been sent for the co-traitant {string}') do |siret|
+ member = GroupingMember.find_by!(siret:)
+ expect(member.reload.invitation_sent?).to be true
+end
diff --git a/features/step_definitions/grouping_legal_type_steps.rb b/features/step_definitions/grouping_legal_type_steps.rb
index f43358ebf..82e445667 100644
--- a/features/step_definitions/grouping_legal_type_steps.rb
+++ b/features/step_definitions/grouping_legal_type_steps.rb
@@ -6,7 +6,7 @@
end
When('I visit the grouping legal type step directly') do
- visit grouping_legal_type_candidate_market_application_path(@market_application.identifier)
+ visit grouping_wizard_step_candidate_market_application_path(@market_application.identifier, :grouping_legal_type)
end
Then('the grouping legal type should be {string}') do |legal_type|
diff --git a/features/step_definitions/lot_selection_mode_steps.rb b/features/step_definitions/lot_selection_mode_steps.rb
new file mode 100644
index 000000000..879705b4a
--- /dev/null
+++ b/features/step_definitions/lot_selection_mode_steps.rb
@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+When('I set lot {string} to {string}') do |lot_name, mode|
+ lot = Lot.find_by!(name: lot_name)
+ find("label[for='lot_mode_#{lot.id}_#{mode}']").click
+end
+
+When('I visit the read-only candidacy mode step of the solo application') do
+ solo_application = @market_application.solo_counterpart || @market_application
+ visit grouping_wizard_step_candidate_market_application_path(solo_application.identifier, :application_mode, readonly: true)
+end
+
+When('I apply {string} to the typology {string}') do |label, market_type_code|
+ section = find('.lot-selection-mode-group', text: I18n.t("market_types.#{market_type_code}"))
+ within(section) { find('option', text: label).select_option }
+end
+
+Then('each lot should offer the options {string}, {string} and {string}') do |*labels|
+ labels.each { |label| expect(page).to have_css('.lot-mode-choice__label', text: label) }
+end
+
+Then('each lot should offer the options {string} and {string}') do |first_label, second_label|
+ expect(page).to have_css('.lot-mode-choice__label', text: first_label)
+ expect(page).to have_css('.lot-mode-choice__label', text: second_label)
+end
+
+Then('the lot option {string} should not be visible') do |label|
+ expect(page).not_to have_css('.lot-mode-choice__label', text: label)
+end
+
+Then('every lot should be set to {string}') do |label|
+ mode = mode_key_for_label(label)
+ page.all("input[name^='lot_modes'][value='#{mode}']").each do |radio|
+ expect(radio).to be_checked
+ end
+end
+
+Then('lot {string} should be set to {string}') do |lot_name, label|
+ lot = Lot.find_by!(name: lot_name)
+ mode = mode_key_for_label(label)
+ expect(page).to have_css("#lot_mode_#{lot.id}_#{mode}:checked", visible: :all)
+end
+
+Then('every lot of the typology {string} should be set to {string}') do |market_type_code, label|
+ mode = mode_key_for_label(label)
+ market_type = MarketType.find_by!(code: market_type_code)
+ Lot.where(market_type:).or(Lot.where(platform_market_type: market_type)).each do |lot|
+ expect(page).to have_css("#lot_mode_#{lot.id}_#{mode}:checked", visible: :all)
+ end
+end
+
+Then('I should see a section for the lot typology {string}') do |market_type_code|
+ expect(page).to have_css('.lot-selection-mode-group', text: I18n.t("market_types.#{market_type_code}"))
+end
+
+def mode_key_for_label(label)
+ %w[solo groupement none].find { |mode| I18n.t("candidate.lot_selection_modes.#{mode}") == label }
+end
diff --git a/spec/interactors/candidate/add_grouping_member_spec.rb b/spec/interactors/candidate/add_grouping_member_spec.rb
new file mode 100644
index 000000000..f44e6aa85
--- /dev/null
+++ b/spec/interactors/candidate/add_grouping_member_spec.rb
@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Candidate::AddGroupingMember, type: :interactor do
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:) }
+ let(:mandataire_application) do
+ create(:market_application, public_market:, siret: '73282932000074', application_mode: :groupement)
+ end
+ let(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: mandataire_application, legal_type: :conjoint)
+ end
+
+ before do
+ allow(SiretValidator).to receive(:valid?).and_return(true)
+ end
+
+ describe '.call' do
+ subject(:result) { described_class.call(grouping:, siret:, email:) }
+
+ let(:siret) { '80245139600027' }
+ let(:email) { 'contact@menuiseries-loire.fr' }
+
+ context 'when the SIRET and email are valid and the SIRET is not already in the grouping' do
+ before do
+ allow(FetchRaisonSociale).to receive(:call).and_return(
+ OpenStruct.new(success?: true, raison_sociale: 'MENUISERIES DE LOIRE SARL')
+ )
+ end
+
+ it 'succeeds' do
+ expect(result).to be_success
+ end
+
+ it 'creates a co_traitant grouping member' do
+ expect { result }.to change { grouping.grouping_members.co_traitant.count }.by(1)
+ end
+
+ it 'stores the resolved company name' do
+ member = result.grouping_member
+ expect(member.company_name).to eq('MENUISERIES DE LOIRE SARL')
+ end
+
+ it 'does not send an invitation yet' do
+ member = result.grouping_member
+ expect(member.invitation_sent?).to be false
+ end
+ end
+
+ context 'when the company name API call fails' do
+ before do
+ allow(FetchRaisonSociale).to receive(:call).and_return(
+ OpenStruct.new(success?: false, raison_sociale: nil)
+ )
+ end
+
+ it 'still succeeds and creates the member without a company name' do
+ expect(result).to be_success
+ expect(result.grouping_member.company_name).to be_nil
+ end
+ end
+
+ context 'when the company name API call raises (network error, WebMock, ...)' do
+ before do
+ allow(FetchRaisonSociale).to receive(:call).and_raise(SocketError, 'connection failed')
+ allow(Sentry).to receive(:capture_exception)
+ end
+
+ it 'still succeeds and creates the member without a company name' do
+ expect(result).to be_success
+ expect(result.grouping_member.company_name).to be_nil
+ end
+
+ it 'reports the exception to Sentry' do
+ result
+ expect(Sentry).to have_received(:capture_exception)
+ end
+ end
+
+ context 'when the SIRET is blank' do
+ let(:siret) { '' }
+
+ it 'fails with a siret error' do
+ expect(result).to be_failure
+ expect(result.errors[:siret]).to be_present
+ end
+
+ it 'does not clear the email error slot' do
+ expect(result.errors[:email]).to be_blank
+ end
+ end
+
+ context 'when the SIRET is invalid' do
+ before { allow(SiretValidator).to receive(:valid?).with(siret).and_return(false) }
+
+ it 'fails with a siret error' do
+ expect(result).to be_failure
+ expect(result.errors[:siret]).to be_present
+ end
+ end
+
+ context 'when the SIRET is the mandataire own SIRET' do
+ let(:siret) { mandataire_application.siret }
+
+ it 'fails with a siret error' do
+ expect(result).to be_failure
+ expect(result.errors[:siret]).to be_present
+ end
+ end
+
+ context 'when the SIRET has already been added to the grouping' do
+ before do
+ allow(FetchRaisonSociale).to receive(:call).and_return(
+ OpenStruct.new(success?: true, raison_sociale: 'MENUISERIES DE LOIRE SARL')
+ )
+ create(:grouping_member, :co_traitant, grouping:, siret:)
+ end
+
+ it 'fails with a siret error' do
+ expect(result).to be_failure
+ expect(result.errors[:siret]).to be_present
+ end
+ end
+
+ context 'when the email is blank' do
+ let(:email) { '' }
+
+ it 'fails with an email error' do
+ expect(result).to be_failure
+ expect(result.errors[:email]).to be_present
+ end
+
+ it 'does not clear the siret error slot' do
+ expect(result.errors[:siret]).to be_blank
+ end
+ end
+
+ context 'when the email is invalid' do
+ let(:email) { 'not-an-email' }
+
+ it 'fails with an email error' do
+ expect(result).to be_failure
+ expect(result.errors[:email]).to be_present
+ end
+ end
+ end
+end
diff --git a/spec/interactors/candidate/confirm_grouping_composition_spec.rb b/spec/interactors/candidate/confirm_grouping_composition_spec.rb
new file mode 100644
index 000000000..66ef2acff
--- /dev/null
+++ b/spec/interactors/candidate/confirm_grouping_composition_spec.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Candidate::ConfirmGroupingComposition, type: :interactor do
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:) }
+ let(:mandataire_application) do
+ create(:market_application, public_market:, siret: '73282932000074', application_mode: :groupement)
+ end
+ let(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: mandataire_application, legal_type: :conjoint)
+ end
+
+ before do
+ allow(SiretValidator).to receive(:valid?).and_return(true)
+ end
+
+ describe '.call' do
+ subject(:result) { described_class.call(grouping:) }
+
+ context 'when the grouping has at least one co_traitant' do
+ let!(:member1) { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil) }
+ let!(:member2) { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil) }
+
+ it 'succeeds' do
+ expect(result).to be_success
+ end
+
+ it 'generates an invitation token for each co_traitant' do
+ result
+ expect(member1.reload.invitation_token).to be_present
+ expect(member2.reload.invitation_token).to be_present
+ end
+
+ it 'marks each co_traitant as invited' do
+ result
+ expect(member1.reload.invitation_sent?).to be true
+ expect(member2.reload.invitation_sent?).to be true
+ end
+
+ it 'sends an invitation email to each co_traitant' do
+ expect { result }.to have_enqueued_mail(GroupingInvitationMailer, :invitation).twice
+ end
+
+ it 'does not affect the mandataire member' do
+ mandataire_member = grouping.mandataire_grouping_member
+ result
+ expect(mandataire_member.reload.invitation_token).to be_nil
+ end
+ end
+
+ context 'when a co_traitant has already been invited' do
+ let!(:already_invited) do
+ create(:grouping_member, :co_traitant, grouping:, invitation_token: 'existing-token',
+ invitation_token_created_at: 1.day.ago)
+ end
+ let!(:new_member) { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil) }
+
+ it 'does not resend an invitation to the already invited member' do
+ expect { result }.to have_enqueued_mail(GroupingInvitationMailer, :invitation).once
+ end
+
+ it 'does not change the already invited token' do
+ result
+ expect(already_invited.reload.invitation_token).to eq('existing-token')
+ end
+ end
+
+ context 'when the grouping has no co_traitant' do
+ it 'fails' do
+ expect(result).to be_failure
+ end
+
+ it 'sets an error' do
+ expect(result.errors[:grouping]).to be_present
+ end
+
+ it 'does not send any email' do
+ expect { result }.not_to have_enqueued_mail(GroupingInvitationMailer, :invitation)
+ end
+ end
+ end
+end
diff --git a/spec/interactors/candidate/create_applications_for_mode_spec.rb b/spec/interactors/candidate/create_applications_for_mode_spec.rb
index 3dbcb0aa0..c23927d53 100644
--- a/spec/interactors/candidate/create_applications_for_mode_spec.rb
+++ b/spec/interactors/candidate/create_applications_for_mode_spec.rb
@@ -103,6 +103,16 @@
expect(Grouping.count).to eq(1)
expect(Grouping.last.mandataire_market_application).to eq(result.market_application)
end
+
+ context 'when the candidate is already authenticated on the solo application' do
+ let(:user) { create(:user) }
+ let!(:market_application) { create(:market_application, public_market:, siret:, user:) }
+
+ it 'links the groupement counterpart to the same user' do
+ result = subject
+ expect(result.market_application.user).to eq(user)
+ end
+ end
end
context 'when mixte mode finds an existing groupement application owned by another user' do
diff --git a/spec/interactors/candidate/remove_grouping_member_spec.rb b/spec/interactors/candidate/remove_grouping_member_spec.rb
new file mode 100644
index 000000000..9ff2af938
--- /dev/null
+++ b/spec/interactors/candidate/remove_grouping_member_spec.rb
@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Candidate::RemoveGroupingMember, type: :interactor do
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:) }
+ let(:mandataire_application) do
+ create(:market_application, public_market:, siret: '73282932000074', application_mode: :groupement)
+ end
+ let(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: mandataire_application, legal_type: :conjoint)
+ end
+
+ before do
+ allow(SiretValidator).to receive(:valid?).and_return(true)
+ end
+
+ describe '.call' do
+ subject(:result) { described_class.call(grouping:, grouping_member_id:) }
+
+ context 'when the member exists, belongs to the grouping and has not been invited yet' do
+ let!(:member) { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil) }
+ let(:grouping_member_id) { member.id }
+
+ it 'succeeds' do
+ expect(result).to be_success
+ end
+
+ it 'destroys the member' do
+ expect { result }.to change(GroupingMember, :count).by(-1)
+ end
+ end
+
+ context 'when the member has already been invited' do
+ let!(:member) { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: Time.current) }
+ let(:grouping_member_id) { member.id }
+
+ it 'fails' do
+ expect(result).to be_failure
+ end
+
+ it 'does not destroy the member' do
+ expect { result }.not_to change(GroupingMember, :count)
+ end
+ end
+
+ context 'when the member does not belong to the grouping' do
+ let(:other_grouping) do
+ other_application = create(:market_application, public_market:, siret: '80245139600027',
+ application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: other_application, legal_type: :conjoint)
+ end
+ let!(:member) { create(:grouping_member, :co_traitant, grouping: other_grouping, invitation_token_created_at: nil) }
+ let(:grouping_member_id) { member.id }
+
+ before { grouping }
+
+ it 'fails' do
+ expect(result).to be_failure
+ end
+
+ it 'does not destroy the member' do
+ expect { result }.not_to change(GroupingMember, :count)
+ end
+ end
+
+ context 'when the member does not exist' do
+ let(:grouping_member_id) { -1 }
+
+ it 'fails' do
+ expect(result).to be_failure
+ end
+ end
+ end
+end
diff --git a/spec/interactors/candidate/set_lot_selection_modes_spec.rb b/spec/interactors/candidate/set_lot_selection_modes_spec.rb
new file mode 100644
index 000000000..31773e2e1
--- /dev/null
+++ b/spec/interactors/candidate/set_lot_selection_modes_spec.rb
@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Candidate::SetLotSelectionModes, type: :interactor do
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:) }
+ let(:siret) { '73282932000074' }
+ let(:lot1) { create(:lot, public_market:) }
+ let(:lot2) { create(:lot, public_market:) }
+
+ before do
+ allow(SiretValidator).to receive(:valid?).and_return(true)
+ end
+
+ describe '.call' do
+ context 'in mixte mode (solo and groupement counterpart exist)' do
+ let!(:solo_application) { create(:market_application, public_market:, siret:, application_mode: :solo) }
+ let!(:groupement_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'assigns each lot to the matching application' do
+ result = described_class.call(
+ market_application: solo_application,
+ lot_modes: { lot1.id.to_s => 'solo', lot2.id.to_s => 'groupement' }
+ )
+
+ expect(result).to be_success
+ expect(solo_application.reload.lots).to contain_exactly(lot1)
+ expect(groupement_application.reload.lots).to contain_exactly(lot2)
+ end
+
+ it 'leaves a lot unassigned when its mode is none' do
+ create(:lot, public_market:)
+
+ result = described_class.call(
+ market_application: solo_application,
+ lot_modes: { lot1.id.to_s => 'solo', lot2.id.to_s => 'groupement' }
+ )
+
+ expect(result).to be_success
+ expect(solo_application.reload.lots + groupement_application.reload.lots).to contain_exactly(lot1, lot2)
+ end
+
+ it 'replaces the previous selection on resubmission' do
+ solo_application.lots << lot1
+ groupement_application.lots << lot2
+
+ result = described_class.call(
+ market_application: solo_application,
+ lot_modes: { lot1.id.to_s => 'groupement', lot2.id.to_s => 'solo' }
+ )
+
+ expect(result).to be_success
+ expect(solo_application.reload.lots).to contain_exactly(lot2)
+ expect(groupement_application.reload.lots).to contain_exactly(lot1)
+ end
+
+ it 'fails when no lot is set to solo' do
+ result = described_class.call(
+ market_application: solo_application,
+ lot_modes: { lot1.id.to_s => 'groupement', lot2.id.to_s => 'groupement' }
+ )
+
+ expect(result).to be_failure
+ expect(result.errors[:base]).to be_present
+ end
+
+ it 'fails when no lot is set to groupement' do
+ result = described_class.call(
+ market_application: solo_application,
+ lot_modes: { lot1.id.to_s => 'solo', lot2.id.to_s => 'solo' }
+ )
+
+ expect(result).to be_failure
+ expect(result.errors[:base]).to be_present
+ end
+
+ it 'does not change either application when validation fails' do
+ solo_application.lots << lot1
+
+ result = described_class.call(
+ market_application: solo_application,
+ lot_modes: { lot1.id.to_s => 'solo', lot2.id.to_s => 'solo' }
+ )
+
+ expect(result).to be_failure
+ expect(solo_application.reload.lots).to contain_exactly(lot1)
+ end
+ end
+
+ context 'in groupement-only mode (no solo counterpart)' do
+ let!(:groupement_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'assigns lots set to groupement and succeeds' do
+ result = described_class.call(
+ market_application: groupement_application,
+ lot_modes: { lot1.id.to_s => 'groupement', lot2.id.to_s => 'none' }
+ )
+
+ expect(result).to be_success
+ expect(groupement_application.reload.lots).to contain_exactly(lot1)
+ end
+
+ it 'fails when no lot is set to groupement' do
+ result = described_class.call(
+ market_application: groupement_application,
+ lot_modes: { lot1.id.to_s => 'none', lot2.id.to_s => 'none' }
+ )
+
+ expect(result).to be_failure
+ expect(result.errors[:base]).to be_present
+ end
+ end
+
+ context 'when called on a solo application with no groupement counterpart' do
+ let!(:solo_application) { create(:market_application, public_market:, siret:, application_mode: :solo) }
+
+ it 'fails instead of raising' do
+ result = described_class.call(
+ market_application: solo_application,
+ lot_modes: { lot1.id.to_s => 'groupement' }
+ )
+
+ expect(result).to be_failure
+ expect(result.errors[:base]).to be_present
+ end
+ end
+
+ context 'with an unknown lot id' do
+ let!(:groupement_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'fails' do
+ other_market_lot = create(:lot)
+
+ result = described_class.call(
+ market_application: groupement_application,
+ lot_modes: { other_market_lot.id.to_s => 'groupement' }
+ )
+
+ expect(result).to be_failure
+ expect(result.errors[:lot_ids]).to be_present
+ end
+ end
+ end
+end
diff --git a/spec/interactors/fetch_buyer_name/extract_name_spec.rb b/spec/interactors/fetch_raison_sociale/extract_name_spec.rb
similarity index 79%
rename from spec/interactors/fetch_buyer_name/extract_name_spec.rb
rename to spec/interactors/fetch_raison_sociale/extract_name_spec.rb
index d10e71ca1..bbea56371 100644
--- a/spec/interactors/fetch_buyer_name/extract_name_spec.rb
+++ b/spec/interactors/fetch_raison_sociale/extract_name_spec.rb
@@ -2,7 +2,7 @@
require 'rails_helper'
-RSpec.describe FetchBuyerName::ExtractName, type: :interactor do
+RSpec.describe FetchRaisonSociale::ExtractName, type: :interactor do
include ApiResponses::InseeResponses
let(:siret) { '13002526500013' }
@@ -24,14 +24,14 @@ def build_response_body(raison_sociale:)
subject { described_class.call(response:) }
context 'when raison_sociale is present' do
- let(:response) { instance_double(Net::HTTPOK, body: build_response_body(raison_sociale: 'Ville de Paris')) }
+ let(:response) { instance_double(Net::HTTPOK, body: build_response_body(raison_sociale: 'OCTO TECHNOLOGY')) }
it 'succeeds' do
expect(subject).to be_success
end
- it 'sets buyer_name in context' do
- expect(subject.buyer_name).to eq('Ville de Paris')
+ it 'sets raison_sociale in context' do
+ expect(subject.raison_sociale).to eq('OCTO TECHNOLOGY')
end
end
@@ -42,8 +42,8 @@ def build_response_body(raison_sociale:)
expect(subject).to be_success
end
- it 'sets buyer_name to nil' do
- expect(subject.buyer_name).to be_nil
+ it 'sets raison_sociale to nil' do
+ expect(subject.raison_sociale).to be_nil
end
end
diff --git a/spec/interactors/fetch_buyer_name/make_request_spec.rb b/spec/interactors/fetch_raison_sociale/make_request_spec.rb
similarity index 70%
rename from spec/interactors/fetch_buyer_name/make_request_spec.rb
rename to spec/interactors/fetch_raison_sociale/make_request_spec.rb
index 7a3936e1f..d130e8041 100644
--- a/spec/interactors/fetch_buyer_name/make_request_spec.rb
+++ b/spec/interactors/fetch_raison_sociale/make_request_spec.rb
@@ -2,11 +2,10 @@
require 'rails_helper'
-RSpec.describe FetchBuyerName::MakeRequest, type: :interactor do
+RSpec.describe FetchRaisonSociale::MakeRequest, type: :interactor do
include ApiResponses::InseeResponses
let(:siret) { '13002526500013' }
- let(:public_market) { create(:public_market, :completed, siret:) }
let(:base_url) { 'https://entreprise.api.gouv.fr/' }
let(:token) { 'test_bearer_token_123' }
let(:endpoint_url) { "#{base_url}v3/insee/sirene/etablissements/#{siret}" }
@@ -14,7 +13,7 @@
{
'context' => 'Candidature marché public',
'recipient' => siret,
- 'object' => "Configuration marché: #{public_market.name}"
+ 'object' => 'Réponse appel offre'
}
end
@@ -26,7 +25,7 @@
end
describe '.call' do
- subject { described_class.call(public_market:) }
+ subject { described_class.call(siret:) }
context 'when the API request is successful (HTTP 200)' do
before do
@@ -47,23 +46,30 @@
it_behaves_like 'a successful API request'
- it 'uses the public market SIRET in the endpoint URL' do
+ it 'uses the given SIRET in the endpoint URL' do
subject
expect(a_request(:get, endpoint_url).with(query: hash_including(query_params))).to have_been_made.once
end
+ end
- it 'sends the public market SIRET as recipient' do
- subject
- expect(
- a_request(:get, endpoint_url).with(query: hash_including('recipient' => siret))
- ).to have_been_made.once
+ context 'when a custom request_object is given' do
+ subject { described_class.call(siret:, request_object: 'Configuration marché: Travaux de voirie') }
+
+ before do
+ stub_request(:get, endpoint_url)
+ .with(query: hash_including(query_params.merge('object' => 'Configuration marché: Travaux de voirie')))
+ .to_return(
+ status: 200,
+ body: successful_response_body,
+ headers: { 'Content-Type' => 'application/json' }
+ )
end
- it 'sends the market name as object' do
+ it 'sends the custom object as audit label' do
subject
expect(
a_request(:get, endpoint_url)
- .with(query: hash_including('object' => "Configuration marché: #{public_market.name}"))
+ .with(query: hash_including('object' => 'Configuration marché: Travaux de voirie'))
).to have_been_made.once
end
end
diff --git a/spec/mailers/grouping_invitation_mailer_spec.rb b/spec/mailers/grouping_invitation_mailer_spec.rb
new file mode 100644
index 000000000..1258d31b1
--- /dev/null
+++ b/spec/mailers/grouping_invitation_mailer_spec.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe GroupingInvitationMailer, type: :mailer do
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:, name: 'Marché test informatique') }
+ let(:mandataire_application) do
+ create(:market_application, public_market:, siret: '73282932000074', application_mode: :groupement)
+ end
+ let(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: mandataire_application, legal_type: :conjoint)
+ end
+ let(:grouping_member) do
+ create(:grouping_member, :co_traitant, grouping:, email: 'contact@menuiseries-loire.fr')
+ end
+ let(:url) { 'http://localhost:3000/candidate/grouping_invitations/abc123' }
+
+ before { allow(SiretValidator).to receive(:valid?).and_return(true) }
+
+ describe '#invitation' do
+ let(:mail) { described_class.invitation(grouping_member, url) }
+
+ it 'sends to the grouping member email' do
+ expect(mail.to).to eq([grouping_member.email])
+ end
+
+ it 'sends from the application address' do
+ expect(mail.from).to eq(['noreply@passemarche.data.gouv.fr'])
+ end
+
+ it 'includes the invitation URL in the text body' do
+ expect(mail.text_part.body.decoded).to include(url)
+ end
+
+ it 'includes the market name in the html body' do
+ expect(mail.html_part.body.decoded).to include('Marché test informatique')
+ end
+ end
+end
diff --git a/spec/mailers/previews/grouping_invitation_mailer_preview.rb b/spec/mailers/previews/grouping_invitation_mailer_preview.rb
new file mode 100644
index 000000000..9aaf85f1d
--- /dev/null
+++ b/spec/mailers/previews/grouping_invitation_mailer_preview.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class GroupingInvitationMailerPreview < ActionMailer::Preview
+ def invitation
+ public_market = PublicMarket.new(
+ name: "Système d'acquisition dynamique (SAD) pour la fourniture de matériels informatiques"
+ )
+ grouping = Grouping.new(public_market:)
+ grouping_member = GroupingMember.new(email: 'contact@menuiseries-loire.fr', siret: '80245139600027', grouping:)
+ url = 'http://localhost:3000/candidate/grouping_invitations/abc123'
+
+ GroupingInvitationMailer.invitation(grouping_member, url)
+ end
+end
diff --git a/spec/models/grouping_member_spec.rb b/spec/models/grouping_member_spec.rb
index 23c78c252..c6e644954 100644
--- a/spec/models/grouping_member_spec.rb
+++ b/spec/models/grouping_member_spec.rb
@@ -83,4 +83,37 @@
expect(member).to be_status_completed
end
end
+
+ describe 'siret' do
+ it 'rejects a co_traitant siret equal to the mandataire siret' do
+ member = build(:grouping_member, :co_traitant, grouping:, siret: grouping.mandataire_grouping_member.siret)
+
+ expect(member).not_to be_valid
+ expect(member.errors[:siret]).to be_present
+ end
+
+ it 'allows the mandataire own member to have the mandataire siret' do
+ expect(grouping.mandataire_grouping_member).to be_valid
+ end
+
+ it 'is enforced unique within a grouping at the database level' do
+ create(:grouping_member, :co_traitant, grouping:, siret: '80245139600027')
+ duplicate = build(:grouping_member, :co_traitant, grouping:, siret: '80245139600027')
+
+ expect(duplicate).not_to be_valid
+ expect(duplicate.errors[:siret]).to be_present
+ end
+ end
+
+ describe '#invitation_sent?' do
+ it 'is false when the invitation has not been sent yet' do
+ member = build(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil)
+ expect(member.invitation_sent?).to be false
+ end
+
+ it 'is true once the invitation has been sent' do
+ member = build(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: Time.current)
+ expect(member.invitation_sent?).to be true
+ end
+ end
end
diff --git a/spec/models/market_application_spec.rb b/spec/models/market_application_spec.rb
index 04697da44..68abef4d0 100644
--- a/spec/models/market_application_spec.rb
+++ b/spec/models/market_application_spec.rb
@@ -206,6 +206,202 @@
end
end
+ describe '#grouping_composition_choice_required?' do
+ it 'returns false when the groupement feature flag is disabled' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: application, legal_type: :conjoint)
+
+ expect(application.grouping_composition_choice_required?).to be false
+ end
+
+ it 'returns false when the legal_type has not been chosen yet' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: application, legal_type: nil)
+
+ expect(application.grouping_composition_choice_required?).to be false
+ end
+
+ it 'returns true when legal_type is chosen but no invitation has been sent yet' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ grouping = create(:grouping, public_market:, mandataire_market_application: application, legal_type: :conjoint)
+ create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil)
+
+ expect(application.grouping_composition_choice_required?).to be true
+ end
+
+ it 'returns false once at least one invitation has been sent' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ grouping = create(:grouping, public_market:, mandataire_market_application: application, legal_type: :conjoint)
+ create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: Time.current)
+
+ expect(application.grouping_composition_choice_required?).to be false
+ end
+
+ it 'returns false when the mode is not groupement' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = build(:market_application, public_market:, application_mode: :solo)
+
+ expect(application.grouping_composition_choice_required?).to be false
+ end
+ end
+
+ describe '#lot_selection_mode_choice_required?' do
+ it 'returns false when the groupement feature flag is disabled' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ create(:lot, public_market:)
+
+ expect(application.lot_selection_mode_choice_required?).to be false
+ end
+
+ it 'returns false when the mode is not groupement' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = build(:market_application, public_market:, application_mode: :solo)
+
+ expect(application.lot_selection_mode_choice_required?).to be false
+ end
+
+ it 'returns false when the public market has no lots' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+
+ expect(application.lot_selection_mode_choice_required?).to be false
+ end
+
+ it 'returns true when groupement and no lot has been assigned yet' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ create(:lot, public_market:)
+
+ expect(application.lot_selection_mode_choice_required?).to be true
+ end
+
+ it 'returns false once a lot has been assigned to the groupement application' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ lot = create(:lot, public_market:)
+ application.lots << lot
+
+ expect(application.lot_selection_mode_choice_required?).to be false
+ end
+
+ it 'returns false once a lot has been assigned to the solo counterpart in mixte mode' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ siret = '73282932000074'
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+ groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+ lot = create(:lot, public_market:)
+ solo.lots << lot
+
+ expect(groupement.lot_selection_mode_choice_required?).to be false
+ end
+ end
+
+ describe '#groupement_counterpart' do
+ let(:siret) { '73282932000074' }
+
+ it 'finds the groupement application for the same SIRET and market when called on the solo one' do
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+ groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+
+ expect(solo.groupement_counterpart).to eq(groupement)
+ end
+
+ it 'returns nil when the application is not mixte-related (only a solo exists)' do
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+ expect(solo.groupement_counterpart).to be_nil
+ end
+
+ it 'returns nil when the application itself is the groupement one' do
+ groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+
+ expect(groupement.groupement_counterpart).to be_nil
+ end
+
+ it 'returns nil for a solo application that is not part of a mixte pair on another market' do
+ other_market = create(:public_market, :completed, editor:)
+ create(:market_application, public_market: other_market, siret:, application_mode: :groupement)
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+ expect(solo.groupement_counterpart).to be_nil
+ end
+ end
+
+ describe '#solo_counterpart' do
+ let(:siret) { '73282932000074' }
+
+ it 'finds the solo application for the same SIRET and market when called on the groupement one' do
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+ groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+
+ expect(groupement.solo_counterpart).to eq(solo)
+ end
+
+ it 'returns nil when the application is not mixte-related (only a groupement exists)' do
+ groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+
+ expect(groupement.solo_counterpart).to be_nil
+ end
+
+ it 'returns nil when the application itself is the solo one' do
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+
+ expect(solo.solo_counterpart).to be_nil
+ end
+ end
+
+ describe '#next_required_wizard_step' do
+ it 'returns application_mode when the mode has not been chosen yet' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = build(:market_application, public_market:, application_mode: nil)
+
+ expect(application.next_required_wizard_step).to eq([application, :application_mode])
+ end
+
+ it 'returns lot_selection_mode on the groupement counterpart when no lot has been assigned yet' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ siret = '73282932000074'
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+ groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+ create(:lot, public_market:)
+
+ expect(solo.next_required_wizard_step).to eq([groupement, :lot_selection_mode])
+ end
+
+ it 'returns grouping_legal_type on the groupement counterpart once lots have been assigned' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ siret = '73282932000074'
+ solo = create(:market_application, public_market:, siret:, application_mode: :solo)
+ groupement = create(:market_application, public_market:, siret:, application_mode: :groupement)
+ lot = create(:lot, public_market:)
+ groupement.lots << lot
+ create(:grouping, public_market:, mandataire_market_application: groupement, legal_type: nil)
+
+ expect(solo.next_required_wizard_step).to eq([groupement, :grouping_legal_type])
+ end
+
+ it 'returns grouping_composition when the legal_type is chosen but no invitation has been sent' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :groupement)
+ grouping = create(:grouping, public_market:, mandataire_market_application: application, legal_type: :conjoint)
+ create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil)
+
+ expect(application.next_required_wizard_step).to eq([application, :grouping_composition])
+ end
+
+ it 'returns nil once nothing is required' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ application = create(:market_application, public_market:, application_mode: :solo)
+
+ expect(application.next_required_wizard_step).to be_nil
+ end
+ end
+
describe '#in_progress?' do
it 'returns true when not completed' do
application = build(:market_application, public_market:)
diff --git a/spec/organizers/fetch_buyer_name_spec.rb b/spec/organizers/fetch_raison_sociale_spec.rb
similarity index 64%
rename from spec/organizers/fetch_buyer_name_spec.rb
rename to spec/organizers/fetch_raison_sociale_spec.rb
index 01a6fcbf8..186db57fb 100644
--- a/spec/organizers/fetch_buyer_name_spec.rb
+++ b/spec/organizers/fetch_raison_sociale_spec.rb
@@ -2,25 +2,21 @@
require 'rails_helper'
-RSpec.describe FetchBuyerName, type: :organizer do
+RSpec.describe FetchRaisonSociale, type: :organizer do
include ApiResponses::InseeResponses
let(:siret) { '13002526500013' }
- let(:public_market) { create(:public_market, :completed, siret:) }
let(:base_url) { 'https://entreprise.api.gouv.fr/' }
let(:api_url) { "#{base_url}v3/insee/sirene/etablissements/#{siret}" }
let(:token) { 'test_token_123' }
- ApiEntrepriseCredentials = Struct.new(:base_url, :token)
-
before do
- allow(Rails.application.credentials).to receive(:api_entreprise).and_return(
- ApiEntrepriseCredentials.new(base_url, token)
- )
+ allow(Rails.application.credentials).to receive_message_chain(:api_entreprise, :base_url).and_return(base_url)
+ allow(Rails.application.credentials).to receive_message_chain(:api_entreprise, :token).and_return(token)
end
describe '.call' do
- subject { described_class.call(public_market:) }
+ subject { described_class.call(siret:) }
context 'when the API call is successful' do
before do
@@ -29,7 +25,7 @@
query: hash_including(
'context' => 'Candidature marché public',
'recipient' => siret,
- 'object' => "Configuration marché: #{public_market.name}"
+ 'object' => 'Réponse appel offre'
),
headers: { 'Authorization' => "Bearer #{token}" }
)
@@ -44,8 +40,8 @@
expect(subject).to be_success
end
- it 'sets buyer_name in context' do
- expect(subject.buyer_name).to eq('OCTO TECHNOLOGY')
+ it 'sets raison_sociale in context' do
+ expect(subject.raison_sociale).to eq('OCTO TECHNOLOGY')
end
end
@@ -60,16 +56,14 @@
expect(subject).to be_failure
end
- it 'does not set buyer_name' do
- expect(subject.buyer_name).to be_nil
+ it 'does not set raison_sociale' do
+ expect(subject.raison_sociale).to be_nil
end
end
context 'when credentials are missing' do
before do
- allow(Rails.application.credentials).to receive(:api_entreprise).and_return(
- OpenStruct.new(base_url:, token: nil)
- )
+ allow(Rails.application.credentials).to receive_message_chain(:api_entreprise, :token).and_return(nil)
end
it 'fails' do
diff --git a/spec/presenters/candidate/lot_selection_mode_presenter_spec.rb b/spec/presenters/candidate/lot_selection_mode_presenter_spec.rb
new file mode 100644
index 000000000..388816fda
--- /dev/null
+++ b/spec/presenters/candidate/lot_selection_mode_presenter_spec.rb
@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Candidate::LotSelectionModePresenter do
+ subject(:presenter) { described_class.new(market_application) }
+
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:) }
+ let(:siret) { '73282932000074' }
+ let(:lot1) { create(:lot, public_market:) }
+ let(:lot2) { create(:lot, public_market:) }
+
+ before do
+ allow(SiretValidator).to receive(:valid?).and_return(true)
+ lot1
+ lot2
+ end
+
+ describe '#requires_solo_and_groupement?' do
+ context 'when a solo counterpart exists (mixte mode)' do
+ let!(:solo_application) { create(:market_application, public_market:, siret:, application_mode: :solo) }
+ let(:market_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'returns true' do
+ expect(presenter.requires_solo_and_groupement?).to be true
+ end
+ end
+
+ context 'when no solo counterpart exists (groupement only)' do
+ let(:market_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'returns false' do
+ expect(presenter.requires_solo_and_groupement?).to be false
+ end
+ end
+ end
+
+ describe '#mode_for' do
+ context 'in mixte mode' do
+ let!(:solo_application) { create(:market_application, public_market:, siret:, application_mode: :solo) }
+ let(:market_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'defaults to groupement when no lot has been assigned yet' do
+ expect(presenter.mode_for(lot1)).to eq('groupement')
+ expect(presenter.mode_for(lot2)).to eq('groupement')
+ end
+
+ it 'returns solo for a lot assigned to the solo application' do
+ solo_application.lots << lot1
+
+ expect(presenter.mode_for(lot1)).to eq('solo')
+ end
+
+ it 'returns groupement for a lot assigned to the groupement application' do
+ market_application.lots << lot1
+
+ expect(presenter.mode_for(lot1)).to eq('groupement')
+ end
+
+ it 'returns none for a lot assigned to neither once a selection exists' do
+ solo_application.lots << lot1
+
+ expect(presenter.mode_for(lot2)).to eq('none')
+ end
+ end
+
+ context 'in groupement-only mode' do
+ let(:market_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'defaults to groupement when no lot has been assigned yet' do
+ expect(presenter.mode_for(lot1)).to eq('groupement')
+ end
+
+ it 'returns none for a lot left unassigned once a selection exists' do
+ market_application.lots << lot1
+
+ expect(presenter.mode_for(lot2)).to eq('none')
+ end
+ end
+ end
+
+ describe '#lots_by_type_sorted' do
+ let(:market_application) { create(:market_application, public_market:, siret:, application_mode: :groupement) }
+
+ it 'groups the public market lots by their effective market type' do
+ grouped = presenter.lots_by_type_sorted
+
+ expect(grouped.values.flatten).to contain_exactly(lot1, lot2)
+ end
+ end
+end
diff --git a/spec/requests/api/v1/market_applications_spec.rb b/spec/requests/api/v1/market_applications_spec.rb
index b0a93bc78..614b7865b 100644
--- a/spec/requests/api/v1/market_applications_spec.rb
+++ b/spec/requests/api/v1/market_applications_spec.rb
@@ -7,6 +7,8 @@
let(:public_market) { create(:public_market, :published, editor:) }
let(:access_token) { oauth_access_token_for(editor) }
+ before { allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false) }
+
describe 'POST /api/v1/public_markets/:public_market_id/market_applications' do
let(:valid_siret) { '73282932000074' }
let(:invalid_siret) { '12345678901234' }
@@ -111,6 +113,23 @@
expect(json_response['application_url']).to include('/company_identification')
end
+ it 'points to the groupement counterpart grouping_legal_type step when the existing application is mixte' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ solo_application = create(:market_application, public_market:, siret: valid_siret, application_mode: :solo)
+ groupement_application = create(:market_application, public_market:, siret: valid_siret, application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: groupement_application, legal_type: nil)
+
+ post "/api/v1/public_markets/#{public_market.identifier}/market_applications",
+ params: valid_params,
+ headers: { 'Authorization' => "Bearer #{access_token}" },
+ as: :json
+
+ expect(response).to have_http_status(:ok)
+ json_response = response.parsed_body
+ expect(json_response['identifier']).to eq(solo_application.identifier)
+ expect(json_response['application_url']).to include("/#{groupement_application.identifier}/grouping_wizard/grouping_legal_type")
+ end
+
it 'returns error when public market not found' do
post '/api/v1/public_markets/NONEXISTENT/market_applications',
params: valid_params,
diff --git a/spec/requests/candidate/application_modes_spec.rb b/spec/requests/candidate/application_modes_spec.rb
deleted file mode 100644
index c703f90cc..000000000
--- a/spec/requests/candidate/application_modes_spec.rb
+++ /dev/null
@@ -1,257 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe 'Candidate::ApplicationModes', type: :request do
- let(:editor) { create(:editor) }
- let(:public_market) { create(:public_market, :completed, editor:) }
- let(:market_application) { create(:market_application, public_market:, siret: '73282932000074') }
- let(:user) { create(:user) }
-
- before do
- allow(SiretValidator).to receive(:valid?).and_return(true)
- allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
- sign_in_as_candidate(user, market_application)
- end
-
- describe 'authentication' do
- it 'renders the login form instead of the page when not authenticated' do
- other_application = create(:market_application, public_market:, siret: '11122233300014')
-
- get application_mode_candidate_market_application_path(other_application.identifier)
-
- expect(response).to have_http_status(:ok)
- expect(response.body).to include(I18n.t('candidate.sessions.new.title'))
- expect(response.body).not_to include(I18n.t('candidate.application_modes.title'))
- end
- end
-
- describe 'GET /candidate/market_applications/:identifier/application_mode' do
- it 'renders successfully when the mode is not chosen yet' do
- get application_mode_candidate_market_application_path(market_application.identifier)
- expect(response).to have_http_status(:ok)
- end
-
- it 'returns 404 when the feature flag is disabled' do
- allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
-
- get application_mode_candidate_market_application_path(market_application.identifier)
- expect(response).to have_http_status(:not_found)
- end
-
- it 'redirects to company_identification when the mode is already chosen' do
- market_application.update!(application_mode: :solo)
-
- get application_mode_candidate_market_application_path(market_application.identifier)
- expect(response).to redirect_to(
- company_identification_candidate_market_application_path(market_application.identifier)
- )
- end
-
- context 'when the mode is groupement and the legal type is not chosen yet' do
- before do
- market_application.update!(application_mode: :groupement)
- create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
- end
-
- it 'redirects to grouping_legal_type instead of company_identification' do
- get application_mode_candidate_market_application_path(market_application.identifier)
-
- expect(response).to redirect_to(
- grouping_legal_type_candidate_market_application_path(market_application.identifier)
- )
- end
- end
-
- context 'when the mode is groupement and the legal type is already chosen' do
- before do
- market_application.update!(application_mode: :groupement)
- create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
- end
-
- it 'redirects to company_identification' do
- get application_mode_candidate_market_application_path(market_application.identifier)
-
- expect(response).to redirect_to(
- company_identification_candidate_market_application_path(market_application.identifier)
- )
- end
- end
-
- context 'when readonly is requested and the mode is already chosen' do
- before do
- market_application.update!(application_mode: :groupement)
- create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
- end
-
- it 'renders the screen instead of redirecting' do
- get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
-
- expect(response).to have_http_status(:ok)
- end
-
- it 'disables the fieldset' do
- get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
-
- rendered = Nokogiri::HTML(response.body)
- expect(rendered.at_css('fieldset')['disabled']).to eq('disabled')
- end
-
- it 'checks the already chosen mode' do
- get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
-
- rendered = Nokogiri::HTML(response.body)
- expect(rendered.at_css('#application_mode_groupement')['checked']).to eq('checked')
- end
-
- it 'does not show the already-mandataire-elsewhere callout for its own grouping' do
- get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
-
- rendered = Nokogiri::HTML(response.body)
- expect(rendered.text).not_to include(I18n.t('candidate.application_modes.already_mandataire_box.title'))
- end
-
- it 'points the continue link to company_identification since the legal type is already chosen' do
- get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
-
- rendered = Nokogiri::HTML(response.body)
- link = rendered.at_css('a.fr-icon-arrow-right-line')
- expect(link['href']).to eq(company_identification_candidate_market_application_path(market_application.identifier))
- end
- end
-
- context 'when readonly is requested and the legal type is not chosen yet' do
- before do
- market_application.update!(application_mode: :groupement)
- create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
- end
-
- it 'points the continue link to grouping_legal_type' do
- get application_mode_candidate_market_application_path(market_application.identifier, readonly: true)
-
- rendered = Nokogiri::HTML(response.body)
- link = rendered.at_css('a.fr-icon-arrow-right-line')
- expect(link['href']).to eq(grouping_legal_type_candidate_market_application_path(market_application.identifier))
- end
- end
-
- context 'when the application is already completed' do
- let(:market_application) do
- create(:market_application, :completed, public_market:, siret: '73282932000074')
- end
-
- it 'redirects to sync status instead of showing the choice screen' do
- get application_mode_candidate_market_application_path(market_application.identifier)
-
- expect(response).to redirect_to(candidate_sync_status_path(market_application.identifier))
- end
- end
- end
-
- describe 'PATCH /candidate/market_applications/:identifier/application_mode' do
- it 'sets the mode to solo and redirects to company_identification' do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'solo' }
-
- expect(market_application.reload).to be_solo
- expect(response).to redirect_to(
- company_identification_candidate_market_application_path(market_application.identifier)
- )
- end
-
- it 'creates a grouping when choosing groupement' do
- expect do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'groupement' }
- end.to change(Grouping, :count).by(1)
-
- expect(market_application.reload).to be_groupement
- expect(response).to redirect_to(
- grouping_legal_type_candidate_market_application_path(market_application.identifier)
- )
- end
-
- it 'does not require re-authentication when reaching the next step after choosing groupement' do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'groupement' }
-
- get company_identification_candidate_market_application_path(market_application.identifier)
-
- expect(response).to have_http_status(:ok)
- expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
- end
-
- it 'creates two applications when choosing mixte and redirects to grouping_legal_type' do
- expect do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'mixte' }
- end.to change(MarketApplication, :count).by(1)
-
- groupement_application = MarketApplication.find_by(public_market:, siret: market_application.siret,
- application_mode: :groupement)
- expect(response).to redirect_to(
- grouping_legal_type_candidate_market_application_path(groupement_application.identifier)
- )
- end
-
- it 'associates the authenticated user to the groupement counterpart created in mixte mode' do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'mixte' }
-
- groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
- application_mode: :groupement).sole
-
- expect(groupement_application.user).to eq(user)
- end
-
- it 'does not require re-authentication when reaching the next step after choosing mixte' do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'mixte' }
-
- groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
- application_mode: :groupement).sole
-
- get company_identification_candidate_market_application_path(groupement_application.identifier)
-
- expect(response).to have_http_status(:ok)
- expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
- end
-
- context 'when the SIRET is already mandataire of a grouping on this market' do
- before do
- other_application = create(:market_application, public_market:, siret: market_application.siret,
- application_mode: :groupement)
- create(:grouping, public_market:, mandataire_market_application: other_application)
- end
-
- it 'rejects groupement mode with a 422' do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'groupement' }
-
- expect(response).to have_http_status(:unprocessable_content)
- expect(market_application.reload.application_mode).to be_nil
- end
-
- it 'renders the already-mandataire error message and re-disables groupement/mixte' do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'groupement' }
-
- rendered = Nokogiri::HTML(response.body)
- expect(rendered.text).to include(I18n.t('candidate.validations.already_mandataire'))
- expect(rendered.text).to include(I18n.t('candidate.application_modes.already_mandataire_box.title'))
-
- expect(rendered.at_css('#application_mode_groupement')['disabled']).to eq('disabled')
- expect(rendered.at_css('#application_mode_mixte')['disabled']).to eq('disabled')
- end
-
- it 'still allows solo mode' do
- patch application_mode_candidate_market_application_path(market_application.identifier),
- params: { application_mode: 'solo' }
-
- expect(response).to redirect_to(
- company_identification_candidate_market_application_path(market_application.identifier)
- )
- end
- end
- end
-end
diff --git a/spec/requests/candidate/company_identifications_spec.rb b/spec/requests/candidate/company_identifications_spec.rb
index fab8764d7..5b1bd3a4d 100644
--- a/spec/requests/candidate/company_identifications_spec.rb
+++ b/spec/requests/candidate/company_identifications_spec.rb
@@ -45,7 +45,7 @@
get company_identification_candidate_market_application_path(market_application.identifier)
expect(response).to redirect_to(
- application_mode_candidate_market_application_path(market_application.identifier)
+ grouping_wizard_step_candidate_market_application_path(market_application.identifier, :application_mode)
)
end
end
diff --git a/spec/requests/candidate/grouping_invitations_spec.rb b/spec/requests/candidate/grouping_invitations_spec.rb
new file mode 100644
index 000000000..6050cb540
--- /dev/null
+++ b/spec/requests/candidate/grouping_invitations_spec.rb
@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Candidate::GroupingInvitations', type: :request do
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:) }
+ let(:mandataire_application) do
+ create(:market_application, public_market:, siret: '73282932000074', application_mode: :groupement)
+ end
+ let(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: mandataire_application, legal_type: :conjoint)
+ end
+
+ before { allow(SiretValidator).to receive(:valid?).and_return(true) }
+
+ describe 'GET /candidate/grouping_invitations/:token' do
+ context 'when the token matches an invited grouping member' do
+ let(:grouping_member) do
+ create(:grouping_member, :co_traitant, grouping:, invitation_token: 'valid-token-123',
+ invitation_token_created_at: Time.current)
+ end
+
+ it 'returns a successful response' do
+ get candidate_grouping_invitation_path(grouping_member.invitation_token)
+
+ expect(response).to have_http_status(:ok)
+ end
+ end
+
+ context 'when the token does not match any grouping member' do
+ it 'returns a 404' do
+ get candidate_grouping_invitation_path('unknown-token')
+
+ expect(response).to have_http_status(:not_found)
+ end
+ end
+ end
+end
diff --git a/spec/requests/candidate/grouping_legal_types_spec.rb b/spec/requests/candidate/grouping_legal_types_spec.rb
deleted file mode 100644
index 58a088d1b..000000000
--- a/spec/requests/candidate/grouping_legal_types_spec.rb
+++ /dev/null
@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe 'Candidate::GroupingLegalTypes', type: :request do
- let(:editor) { create(:editor) }
- let(:public_market) { create(:public_market, :completed, editor:) }
- let(:market_application) do
- create(:market_application, public_market:, siret: '73282932000074', application_mode: :groupement)
- end
- let(:user) { create(:user) }
-
- before do
- allow(SiretValidator).to receive(:valid?).and_return(true)
- allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
- sign_in_as_candidate(user, market_application)
- end
-
- describe 'GET /candidate/market_applications/:identifier/grouping_legal_type' do
- context 'when the market_application is mandataire of a grouping' do
- before { create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil) }
-
- it 'renders successfully' do
- get grouping_legal_type_candidate_market_application_path(market_application.identifier)
- expect(response).to have_http_status(:ok)
- expect(response.body).to include(I18n.t('candidate.grouping_legal_types.title'))
- end
-
- it 'returns 404 when the feature flag is disabled' do
- allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
-
- get grouping_legal_type_candidate_market_application_path(market_application.identifier)
- expect(response).to have_http_status(:not_found)
- end
- end
-
- context 'when the market_application is not mandataire of any grouping' do
- it 'redirects to application_mode' do
- get grouping_legal_type_candidate_market_application_path(market_application.identifier)
-
- expect(response).to redirect_to(
- application_mode_candidate_market_application_path(market_application.identifier)
- )
- end
- end
-
- context 'when the application mode is solo' do
- let(:market_application) do
- create(:market_application, public_market:, siret: '73282932000074', application_mode: :solo)
- end
-
- it 'redirects to application_mode' do
- get grouping_legal_type_candidate_market_application_path(market_application.identifier)
-
- expect(response).to redirect_to(
- application_mode_candidate_market_application_path(market_application.identifier)
- )
- end
- end
- end
-
- describe 'PATCH /candidate/market_applications/:identifier/grouping_legal_type' do
- before { create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil) }
-
- it 'sets the legal_type and redirects to company_identification' do
- patch grouping_legal_type_candidate_market_application_path(market_application.identifier),
- params: { legal_type: 'conjoint_mandataire_solidaire' }
-
- expect(Grouping.joins(:mandataire_market_application).find_by(market_applications: { id: market_application.id }).legal_type)
- .to eq('conjoint_mandataire_solidaire')
- expect(response).to redirect_to(
- company_identification_candidate_market_application_path(market_application.identifier)
- )
- end
-
- it 'rejects an invalid legal_type with a 422' do
- patch grouping_legal_type_candidate_market_application_path(market_application.identifier),
- params: { legal_type: 'invalid_garbage' }
-
- expect(response).to have_http_status(:unprocessable_content)
- rendered = Nokogiri::HTML(response.body)
- expect(rendered.text).to include(I18n.t('candidate.validations.legal_type_invalid'))
- end
- end
-end
diff --git a/spec/requests/candidate/grouping_wizard_spec.rb b/spec/requests/candidate/grouping_wizard_spec.rb
new file mode 100644
index 000000000..f4f5af653
--- /dev/null
+++ b/spec/requests/candidate/grouping_wizard_spec.rb
@@ -0,0 +1,534 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe 'Candidate::GroupingWizard', type: :request do
+ let(:editor) { create(:editor) }
+ let(:public_market) { create(:public_market, :completed, editor:) }
+ let(:market_application) { create(:market_application, public_market:, siret: '73282932000074') }
+ let(:user) { create(:user) }
+
+ before do
+ allow(SiretValidator).to receive(:valid?).and_return(true)
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(true)
+ sign_in_as_candidate(user, market_application)
+ end
+
+ def wizard_step_path(market_application, step)
+ grouping_wizard_step_candidate_market_application_path(market_application.identifier, step)
+ end
+
+ describe 'authentication' do
+ it 'renders the login form instead of the page when not authenticated' do
+ other_application = create(:market_application, public_market:, siret: '11122233300014')
+
+ get wizard_step_path(other_application, :application_mode)
+
+ expect(response).to have_http_status(:ok)
+ expect(response.body).to include(I18n.t('candidate.sessions.new.title'))
+ expect(response.body).not_to include(I18n.t('candidate.application_modes.title'))
+ end
+ end
+
+ describe 'GET .../grouping_wizard/application_mode' do
+ it 'renders successfully when the mode is not chosen yet' do
+ get wizard_step_path(market_application, :application_mode)
+ expect(response).to have_http_status(:ok)
+ end
+
+ it 'returns 404 when the feature flag is disabled' do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
+
+ get wizard_step_path(market_application, :application_mode)
+ expect(response).to have_http_status(:not_found)
+ end
+
+ it 'redirects to company_identification when the mode is already chosen and readonly is not requested' do
+ market_application.update!(application_mode: :solo)
+
+ get wizard_step_path(market_application, :application_mode)
+ expect(response).to redirect_to(
+ company_identification_candidate_market_application_path(market_application.identifier)
+ )
+ end
+
+ context 'when the application is already completed' do
+ let(:market_application) do
+ create(:market_application, :completed, public_market:, siret: '73282932000074')
+ end
+
+ it 'redirects to sync status instead of showing the choice screen' do
+ get wizard_step_path(market_application, :application_mode)
+
+ expect(response).to redirect_to(candidate_sync_status_path(market_application.identifier))
+ end
+ end
+ end
+
+ describe 'PATCH .../grouping_wizard/application_mode' do
+ it 'sets the mode to solo and redirects to company_identification' do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
+
+ expect(market_application.reload).to be_solo
+ expect(response).to redirect_to(
+ company_identification_candidate_market_application_path(market_application.identifier)
+ )
+ end
+
+ it 'creates a grouping when choosing groupement and redirects to grouping_legal_type' do
+ expect do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+ end.to change(Grouping, :count).by(1)
+
+ expect(market_application.reload).to be_groupement
+ expect(response).to redirect_to(wizard_step_path(market_application, :grouping_legal_type))
+ end
+
+ it 'creates two applications when choosing mixte and redirects to grouping_legal_type of the groupement counterpart' do
+ expect do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'mixte' }
+ end.to change(MarketApplication, :count).by(1)
+
+ groupement_application = MarketApplication.find_by(public_market:, siret: market_application.siret,
+ application_mode: :groupement)
+ expect(response).to redirect_to(wizard_step_path(groupement_application, :grouping_legal_type))
+ end
+
+ it 'does not require re-authentication when reaching the next step after choosing groupement' do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+
+ get wizard_step_path(market_application, :grouping_legal_type)
+
+ expect(response).to have_http_status(:ok)
+ expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
+ end
+
+ it 'associates the authenticated user to the groupement counterpart created in mixte mode' do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'mixte' }
+
+ groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
+ application_mode: :groupement).sole
+
+ expect(groupement_application.user).to eq(user)
+ end
+
+ it 'does not require re-authentication when reaching the next step after choosing mixte' do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'mixte' }
+
+ groupement_application = MarketApplication.where(public_market:, siret: market_application.siret,
+ application_mode: :groupement).sole
+
+ get wizard_step_path(groupement_application, :grouping_legal_type)
+
+ expect(response).to have_http_status(:ok)
+ expect(response.body).not_to include(I18n.t('candidate.sessions.new.siret_label'))
+ end
+
+ context 'when the SIRET is already mandataire of a grouping on this market' do
+ before do
+ other_application = create(:market_application, public_market:, siret: market_application.siret,
+ application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: other_application)
+ end
+
+ it 'rejects groupement mode with a 422' do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+
+ expect(response).to have_http_status(:unprocessable_content)
+ expect(market_application.reload.application_mode).to be_nil
+ end
+
+ it 'renders the already-mandataire error message and re-disables groupement/mixte' do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'groupement' }
+
+ rendered = Nokogiri::HTML(response.body)
+ expect(rendered.text).to include(I18n.t('candidate.validations.already_mandataire'))
+ expect(rendered.text).to include(I18n.t('candidate.application_modes.already_mandataire_box.title'))
+
+ expect(rendered.at_css('#application_mode_groupement')['disabled']).to eq('disabled')
+ expect(rendered.at_css('#application_mode_mixte')['disabled']).to eq('disabled')
+ end
+
+ it 'still allows solo mode' do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
+
+ expect(response).to redirect_to(
+ company_identification_candidate_market_application_path(market_application.identifier)
+ )
+ end
+ end
+
+ context 'when the mode is already chosen' do
+ before do
+ market_application.update!(application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ end
+
+ it 'ignores the resubmitted mode and redirects to the current step, without changing application_mode' do
+ expect do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
+ end.not_to change { market_application.reload.application_mode }
+
+ expect(response).to redirect_to(wizard_step_path(market_application, :grouping_legal_type))
+ end
+
+ it 'does not orphan the existing grouping' do
+ expect do
+ patch wizard_step_path(market_application, :application_mode), params: { application_mode: 'solo' }
+ end.not_to change(Grouping, :count)
+ end
+ end
+ end
+
+ describe 'readonly navigation (application_mode already chosen)' do
+ context 'when the mode is groupement and no co-traitant has been added yet' do
+ before do
+ market_application.update!(application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ end
+
+ it 'renders the screen in readonly instead of redirecting' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ expect(response).to have_http_status(:ok)
+ end
+
+ it 'disables the fieldset' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ expect(rendered.at_css('fieldset')['disabled']).to eq('disabled')
+ end
+
+ it 'checks the already chosen mode' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ expect(rendered.at_css('#application_mode_groupement')['checked']).to eq('checked')
+ end
+
+ it 'does not show the already-mandataire-elsewhere callout for its own grouping' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ expect(rendered.text).not_to include(I18n.t('candidate.application_modes.already_mandataire_box.title'))
+ end
+
+ it 'points the continue link to grouping_legal_type, not skipping it' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ link = rendered.at_css('a.fr-icon-arrow-right-line')
+ expect(link['href']).to eq(wizard_step_path(market_application, :grouping_legal_type))
+ end
+ end
+
+ context 'regression: revisiting application_mode after the legal type is already chosen must not skip it' do
+ before do
+ market_application.update!(application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ end
+
+ it 'still points the continue link to grouping_legal_type (never jumps straight to grouping_composition)' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ link = rendered.at_css('a.fr-icon-arrow-right-line')
+ expect(link['href']).to eq(wizard_step_path(market_application, :grouping_legal_type))
+ end
+
+ it 'allows navigating back to grouping_legal_type and seeing the previously chosen type' do
+ get wizard_step_path(market_application, :grouping_legal_type)
+
+ rendered = Nokogiri::HTML(response.body)
+ expect(rendered.at_css('#legal_type_conjoint')['checked']).to eq('checked')
+ end
+ end
+
+ context 'when the mode is not groupement/mixte (solo)' do
+ before { market_application.update!(application_mode: :solo) }
+
+ it 'points the continue link to company_identification' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ link = rendered.at_css('a.fr-icon-arrow-right-line')
+ expect(link['href']).to eq(company_identification_candidate_market_application_path(market_application.identifier))
+ end
+ end
+
+ context 'for the solo side of a mixte application with an incomplete groupement counterpart' do
+ let!(:groupement_application) do
+ create(:market_application, public_market:, siret: market_application.siret, application_mode: :groupement, user:)
+ end
+
+ before do
+ market_application.update!(application_mode: :solo)
+ create(:grouping, public_market:, mandataire_market_application: groupement_application, legal_type: nil)
+ end
+
+ it 'points the continue link to the groupement counterpart grouping_legal_type step' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ link = rendered.at_css('a.fr-icon-arrow-right-line')
+ expect(link['href']).to eq(wizard_step_path(groupement_application, :grouping_legal_type))
+ end
+ end
+
+ context 'for the solo side of a mixte application with a completed groupement counterpart' do
+ let!(:groupement_application) do
+ create(:market_application, public_market:, siret: market_application.siret, application_mode: :groupement, user:)
+ end
+
+ before do
+ market_application.update!(application_mode: :solo)
+ grouping = create(:grouping, public_market:, mandataire_market_application: groupement_application, legal_type: :conjoint)
+ create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: Time.current)
+ end
+
+ it 'points the continue link to its own company_identification step' do
+ get wizard_step_path(market_application, :application_mode), params: { readonly: true }
+
+ rendered = Nokogiri::HTML(response.body)
+ link = rendered.at_css('a.fr-icon-arrow-right-line')
+ expect(link['href']).to eq(company_identification_candidate_market_application_path(market_application.identifier))
+ end
+ end
+ end
+
+ describe 'GET .../grouping_wizard/grouping_legal_type' do
+ context 'when the market_application is mandataire of a grouping' do
+ before do
+ market_application.update!(application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
+ end
+
+ it 'renders successfully' do
+ get wizard_step_path(market_application, :grouping_legal_type)
+ expect(response).to have_http_status(:ok)
+ expect(response.body).to include(I18n.t('candidate.grouping_legal_types.title'))
+ end
+ end
+
+ context 'when the market_application is not mandataire of any grouping (mode not chosen)' do
+ it 'redirects to application_mode' do
+ get wizard_step_path(market_application, :grouping_legal_type)
+
+ expect(response).to redirect_to(wizard_step_path(market_application, :application_mode))
+ end
+ end
+
+ context 'when the application mode is solo' do
+ before { market_application.update!(application_mode: :solo) }
+
+ it 'redirects to application_mode' do
+ get wizard_step_path(market_application, :grouping_legal_type)
+
+ expect(response).to redirect_to(wizard_step_path(market_application, :application_mode))
+ end
+ end
+ end
+
+ describe 'PATCH .../grouping_wizard/grouping_legal_type' do
+ before do
+ market_application.update!(application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: nil)
+ end
+
+ it 'sets the legal_type and redirects to grouping_composition' do
+ patch wizard_step_path(market_application, :grouping_legal_type), params: { legal_type: 'conjoint_mandataire_solidaire' }
+
+ grouping = Grouping.joins(:mandataire_grouping_member)
+ .find_by(mandataire_grouping_member: { market_application_id: market_application.id })
+ expect(grouping.legal_type).to eq('conjoint_mandataire_solidaire')
+ expect(response).to redirect_to(wizard_step_path(market_application, :grouping_composition))
+ end
+
+ it 'rejects an invalid legal_type with a 422' do
+ patch wizard_step_path(market_application, :grouping_legal_type), params: { legal_type: 'invalid_garbage' }
+
+ expect(response).to have_http_status(:unprocessable_content)
+ rendered = Nokogiri::HTML(response.body)
+ expect(rendered.text).to include(I18n.t('candidate.validations.legal_type_invalid'))
+ end
+ end
+
+ describe 'GET .../grouping_wizard/grouping_composition' do
+ context 'when the market_application is mandataire of a grouping with a legal_type' do
+ before do
+ market_application.update!(application_mode: :groupement)
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ allow(FetchRaisonSociale).to receive(:call).and_return(OpenStruct.new(success?: true, raison_sociale: 'ATLANTIQUE BÂTIMENT SAS'))
+ end
+
+ it 'renders successfully' do
+ get wizard_step_path(market_application, :grouping_composition)
+
+ expect(response).to have_http_status(:ok)
+ expect(response.body).to include(I18n.t('candidate.grouping_compositions.title'))
+ end
+ end
+
+ context 'when the mandataire member has no company_name yet' do
+ before { market_application.update!(application_mode: :groupement) }
+
+ let!(:grouping) { create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint) }
+ let!(:mandataire_member) { grouping.mandataire_grouping_member.tap { |m| m.update!(company_name: nil) } }
+
+ before do
+ allow(FetchRaisonSociale).to receive(:call).and_return(
+ OpenStruct.new(success?: true, raison_sociale: 'ATLANTIQUE BÂTIMENT SAS')
+ )
+ end
+
+ it 'resolves and persists the company name' do
+ get wizard_step_path(market_application, :grouping_composition)
+
+ expect(mandataire_member.reload.company_name).to eq('ATLANTIQUE BÂTIMENT SAS')
+ end
+
+ it 'displays the resolved company name' do
+ get wizard_step_path(market_application, :grouping_composition)
+
+ expect(response.body).to include('ATLANTIQUE BÂTIMENT SAS')
+ end
+ end
+
+ context 'when the mandataire member already has a company_name' do
+ before { market_application.update!(application_mode: :groupement) }
+
+ let!(:grouping) { create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint) }
+ let!(:mandataire_member) do
+ grouping.mandataire_grouping_member.tap { |m| m.update!(company_name: 'ATLANTIQUE BÂTIMENT SAS') }
+ end
+
+ it 'does not call the API again' do
+ allow(FetchRaisonSociale).to receive(:call)
+
+ get wizard_step_path(market_application, :grouping_composition)
+
+ expect(FetchRaisonSociale).not_to have_received(:call)
+ end
+ end
+
+ context 'when the market_application is not mandataire of any grouping' do
+ it 'redirects to application_mode' do
+ get wizard_step_path(market_application, :grouping_composition)
+
+ expect(response).to redirect_to(wizard_step_path(market_application, :application_mode))
+ end
+ end
+ end
+
+ describe 'POST .../grouping_wizard/members' do
+ before { market_application.update!(application_mode: :groupement) }
+
+ let!(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ end
+
+ before do
+ allow(FetchRaisonSociale).to receive(:call).and_return(
+ OpenStruct.new(success?: true, raison_sociale: 'MENUISERIES DE LOIRE SARL')
+ )
+ end
+
+ it 'creates a co_traitant member and returns a turbo stream response' do
+ post grouping_wizard_members_candidate_market_application_path(market_application.identifier),
+ params: { siret: '80245139600027', email: 'contact@menuiseries-loire.fr' },
+ headers: { 'Accept' => 'text/vnd.turbo-stream.html' }
+
+ expect(response).to have_http_status(:ok)
+ expect(response.media_type).to eq('text/vnd.turbo-stream.html')
+ expect(grouping.grouping_members.co_traitant.count).to eq(1)
+ end
+
+ it 'renders errors inline without creating a member when the siret is invalid' do
+ allow(SiretValidator).to receive(:valid?).with('0000000000').and_return(false)
+
+ post grouping_wizard_members_candidate_market_application_path(market_application.identifier),
+ params: { siret: '0000000000', email: 'contact@menuiseries-loire.fr' },
+ headers: { 'Accept' => 'text/vnd.turbo-stream.html' }
+
+ expect(response).to have_http_status(:unprocessable_content)
+ expect(grouping.grouping_members.co_traitant.count).to eq(0)
+ expect(response.body).to include(I18n.t('candidate.validations.siret_invalid'))
+ end
+ end
+
+ describe 'DELETE .../grouping_wizard/members/:id' do
+ before { market_application.update!(application_mode: :groupement) }
+
+ let!(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ end
+ let!(:member) { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil) }
+
+ it 'removes the member and returns a turbo stream response' do
+ delete grouping_wizard_member_candidate_market_application_path(market_application.identifier, member.id),
+ headers: { 'Accept' => 'text/vnd.turbo-stream.html' }
+
+ expect(response).to have_http_status(:ok)
+ expect(GroupingMember.exists?(member.id)).to be false
+ end
+ end
+
+ describe 'GET .../grouping_wizard/grouping_composition_confirmation' do
+ before { market_application.update!(application_mode: :groupement) }
+
+ let!(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ end
+
+ it 'renders the summary' do
+ create(:grouping_member, :co_traitant, grouping:)
+
+ get wizard_step_path(market_application, :grouping_composition_confirmation)
+
+ expect(response).to have_http_status(:ok)
+ expect(response.body).to include(I18n.t('candidate.grouping_compositions.confirm.title'))
+ end
+
+ it 'redirects back to grouping_composition when there is no co-traitant yet' do
+ get wizard_step_path(market_application, :grouping_composition_confirmation)
+
+ expect(response).to redirect_to(wizard_step_path(market_application, :grouping_composition))
+ end
+ end
+
+ describe 'PATCH .../grouping_wizard/grouping_composition_confirmation' do
+ before { market_application.update!(application_mode: :groupement) }
+
+ let!(:grouping) do
+ create(:grouping, public_market:, mandataire_market_application: market_application, legal_type: :conjoint)
+ end
+
+ context 'when the grouping has at least one co_traitant' do
+ before { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil) }
+
+ it 'sends invitations and redirects to the dashboard with a success message' do
+ patch wizard_step_path(market_application, :grouping_composition_confirmation)
+
+ expect(response).to redirect_to(candidate_dashboard_path)
+ follow_redirect!
+ expect(response.body).to include(I18n.t('candidate.grouping_compositions.success'))
+ end
+ end
+
+ context 'when the confirmation interactor fails' do
+ before { create(:grouping_member, :co_traitant, grouping:, invitation_token_created_at: nil) }
+
+ it 'renders the summary with an error' do
+ allow(Candidate::ConfirmGroupingComposition).to receive(:call).and_return(
+ OpenStruct.new(success?: false, errors: { grouping: [I18n.t('candidate.validations.no_co_traitant')] })
+ )
+
+ patch wizard_step_path(market_application, :grouping_composition_confirmation)
+
+ expect(response).to have_http_status(:unprocessable_content)
+ expect(response.body).to include(I18n.t('candidate.validations.no_co_traitant'))
+ end
+ end
+ end
+end
diff --git a/spec/requests/candidate/lot_selections_spec.rb b/spec/requests/candidate/lot_selections_spec.rb
index 3d27848f8..22ed98b52 100644
--- a/spec/requests/candidate/lot_selections_spec.rb
+++ b/spec/requests/candidate/lot_selections_spec.rb
@@ -24,7 +24,7 @@
get lot_selection_candidate_market_application_path(market_application.identifier)
expect(response).to redirect_to(
- application_mode_candidate_market_application_path(market_application.identifier)
+ grouping_wizard_step_candidate_market_application_path(market_application.identifier, :application_mode)
)
end
end
diff --git a/spec/requests/candidate/market_applications_spec.rb b/spec/requests/candidate/market_applications_spec.rb
index c45b030d4..6c7b103f8 100644
--- a/spec/requests/candidate/market_applications_spec.rb
+++ b/spec/requests/candidate/market_applications_spec.rb
@@ -17,6 +17,7 @@
let(:completed_market_application) { create(:market_application, :completed, public_market:, siret: '73282932000074') }
before do
+ allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
allow_any_instance_of(Candidate::ApplicationController).to receive(:current_candidate).and_return(candidate_user)
allow(FeatureFlags::Groupement).to receive(:enabled?).and_return(false)
@@ -101,7 +102,7 @@
get "/candidate/market_applications/#{market_application.identifier}/summary"
expect(response).to redirect_to(
- application_mode_candidate_market_application_path(market_application.identifier)
+ grouping_wizard_step_candidate_market_application_path(market_application.identifier, :application_mode)
)
end
end
@@ -622,7 +623,7 @@ def verify_navigation_through_status_page
delete candidate_market_application_path(market_application.identifier)
expect(response).not_to redirect_to(
- application_mode_candidate_market_application_path(market_application.identifier)
+ grouping_wizard_step_candidate_market_application_path(market_application.identifier, :application_mode)
)
end
end
diff --git a/spec/requests/candidate/sessions_spec.rb b/spec/requests/candidate/sessions_spec.rb
index 19384d07a..422300e23 100644
--- a/spec/requests/candidate/sessions_spec.rb
+++ b/spec/requests/candidate/sessions_spec.rb
@@ -248,7 +248,7 @@
params: { token:, market_application_id: market_application.identifier }
expect(response).to redirect_to(
- application_mode_candidate_market_application_path(market_application.identifier)
+ grouping_wizard_step_candidate_market_application_path(market_application.identifier, :application_mode)
)
end
@@ -262,6 +262,22 @@
step_candidate_market_application_path(market_application.identifier, :company_identification)
)
end
+
+ context 'when the application is the solo side of a mixte candidacy without a user yet' do
+ let!(:groupement_application) do
+ create(:market_application, public_market: market_application.public_market, siret: market_application.siret,
+ application_mode: :groupement)
+ end
+
+ before { market_application.update!(application_mode: :solo) }
+
+ it 'also links the user to the groupement counterpart' do
+ expect do
+ get verify_candidate_sessions_path,
+ params: { token:, market_application_id: market_application.identifier }
+ end.to change { groupement_application.reload.user_id }.from(nil).to(user.id)
+ end
+ end
end
context 'when market has lots and no lots are selected' do