diff --git a/app/assets/javascripts/pages/admin/registrations/groups/new/index.js b/app/assets/javascripts/pages/admin/registrations/groups/new/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0ea2cf01568e813741b6c32f1da03d5c7c42e7cc --- /dev/null +++ b/app/assets/javascripts/pages/admin/registrations/groups/new/index.js @@ -0,0 +1,53 @@ +import Vue from 'vue'; +import GroupProjectFields from '~/registrations/groups/new/components/group_project_fields.vue'; +import createStore from '~/registrations/groups/new/store'; +import GlFieldErrors from '~/gl_field_errors'; +import { parseBoolean } from '~/lib/utils/common_utils'; + +const mountGroupProjectFields = (el, store) => { + if (!el) { + return null; + } + + const { + groupPersisted, + groupId, + groupName, + projectName, + templateName, + initializeWithReadme, + rootUrl, + } = el.dataset; + + return new Vue({ + el, + store, + render(createElement) { + return createElement(GroupProjectFields, { + props: { + importGroup: false, + groupPersisted: parseBoolean(groupPersisted), + groupId: groupId || '', + groupName: groupName || '', + projectName: projectName || '', + templateName: templateName || '', + initializeWithReadme: parseBoolean(initializeWithReadme), + rootUrl, + trackActionForErrors: '', + }, + }); + }, + }); +}; + +const mountCreateGroupProjectFields = () => { + const store = createStore(); + + const elements = document.querySelectorAll('.js-create-group-project-fields'); + + [...elements].map((el) => mountGroupProjectFields(el, store)); + + return new GlFieldErrors(document.querySelectorAll('.gl-show-field-errors')); +}; + +mountCreateGroupProjectFields(); diff --git a/app/assets/javascripts/registrations/groups/new/components/group_project_fields.vue b/app/assets/javascripts/registrations/groups/new/components/group_project_fields.vue new file mode 100644 index 0000000000000000000000000000000000000000..eb22d70a01b6ce1c83cc8648138197a462ed6532 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/components/group_project_fields.vue @@ -0,0 +1,350 @@ + + diff --git a/app/assets/javascripts/registrations/groups/new/components/project_template_selector.vue b/app/assets/javascripts/registrations/groups/new/components/project_template_selector.vue new file mode 100644 index 0000000000000000000000000000000000000000..c87e3bc8aeef2cbbea381ffe44d74ca29ca76dc1 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/components/project_template_selector.vue @@ -0,0 +1,175 @@ + + diff --git a/app/assets/javascripts/registrations/groups/new/constants.js b/app/assets/javascripts/registrations/groups/new/constants.js new file mode 100644 index 0000000000000000000000000000000000000000..7ab720b3e1123a7060c93b3eb398db14fd725f36 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/constants.js @@ -0,0 +1,5 @@ +import { __, s__ } from '~/locale'; + +export const DEFAULT_GROUP_PATH = __('{group}'); +export const DEFAULT_PROJECT_PATH = __('{project}'); +export const DEFAULT_SELECTED_LABEL = s__('ProjectsNew|Select'); diff --git a/app/assets/javascripts/registrations/groups/new/store/actions.js b/app/assets/javascripts/registrations/groups/new/store/actions.js new file mode 100644 index 0000000000000000000000000000000000000000..16c1e9436f777a0e606afac419bd5c9b6bf321c9 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/store/actions.js @@ -0,0 +1,7 @@ +import * as types from './mutation_types'; + +export const setStoreGroupName = ({ commit }, groupName) => + commit(types.SET_STORE_GROUP_NAME, groupName); + +export const setStoreGroupPath = ({ commit }, groupPath) => + commit(types.SET_STORE_GROUP_PATH, groupPath); diff --git a/app/assets/javascripts/registrations/groups/new/store/index.js b/app/assets/javascripts/registrations/groups/new/store/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d711038a4b8b722dd6b8a396493a4b6e20df61b0 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/store/index.js @@ -0,0 +1,14 @@ +import Vue from 'vue'; +import Vuex from 'vuex'; // eslint-disable-line no-restricted-imports +import * as actions from './actions'; +import mutations from './mutations'; +import createState from './state'; + +Vue.use(Vuex); + +export default () => + new Vuex.Store({ + actions, + mutations, + state: createState(), + }); diff --git a/app/assets/javascripts/registrations/groups/new/store/mutation_types.js b/app/assets/javascripts/registrations/groups/new/store/mutation_types.js new file mode 100644 index 0000000000000000000000000000000000000000..192dcf58e9dc3274fdc1b36aa189cf7d826fc798 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/store/mutation_types.js @@ -0,0 +1,2 @@ +export const SET_STORE_GROUP_NAME = 'SET_STORE_GROUP_NAME'; +export const SET_STORE_GROUP_PATH = 'SET_STORE_GROUP_PATH'; diff --git a/app/assets/javascripts/registrations/groups/new/store/mutations.js b/app/assets/javascripts/registrations/groups/new/store/mutations.js new file mode 100644 index 0000000000000000000000000000000000000000..c77dc97a9585c24ce4e6417da39e67daf2babc56 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/store/mutations.js @@ -0,0 +1,10 @@ +import * as types from './mutation_types'; + +export default { + [types.SET_STORE_GROUP_NAME](state, groupName) { + state.storeGroupName = groupName; + }, + [types.SET_STORE_GROUP_PATH](state, groupPath) { + state.storeGroupPath = groupPath; + }, +}; diff --git a/app/assets/javascripts/registrations/groups/new/store/state.js b/app/assets/javascripts/registrations/groups/new/store/state.js new file mode 100644 index 0000000000000000000000000000000000000000..c133f246f92af89bc2f11ffa3b5a1a46ce35b543 --- /dev/null +++ b/app/assets/javascripts/registrations/groups/new/store/state.js @@ -0,0 +1,6 @@ +import { DEFAULT_GROUP_PATH } from '../constants'; + +export default () => ({ + storeGroupName: '', + storeGroupPath: DEFAULT_GROUP_PATH, +}); diff --git a/app/controllers/admin/registrations/groups_controller.rb b/app/controllers/admin/registrations/groups_controller.rb new file mode 100644 index 0000000000000000000000000000000000000000..571efb1bf4f6ba1c2d69e362304e4b12d57a66fe --- /dev/null +++ b/app/controllers/admin/registrations/groups_controller.rb @@ -0,0 +1,78 @@ +# frozen_string_literal: true + +module Admin + module Registrations + class GroupsController < ApplicationController + skip_before_action :set_confirm_warning + before_action :authorize_create_group!, only: :new + + layout 'minimal' + + feature_category :onboarding + + urgency :low, [:create] + + def new + @group = Group.new( + visibility_level: Gitlab::CurrentSettings.default_group_visibility, + name: "#{current_user.username}-group" + ) + @project = Project.new(namespace: @group, name: "#{current_user.username}-project") + @initialize_with_readme = true + end + + def create + ::Gitlab::QueryLimiting.disable!('https://gitlab.com/gitlab-org/gitlab/-/issues/583774') + + result = service_instance.execute + + if result.success? + actions_after_success(result.payload) + else + @group = result.payload[:group] + @project = result.payload[:project] + @template_name = project_params[:template_name] + @initialize_with_readme = project_params[:initialize_with_readme] + + render :new + end + end + + private + + def authorize_create_group! + access_denied! unless current_user.can_admin_all_resources? + end + + def service_instance + Onboarding::SelfManaged::StandardNamespaceCreateService.new(current_user, group_params: group_params, + project_params: project_params) + end + + def actions_after_success(payload) + redirect_to project_path(payload[:project]) + end + + def group_params + params.require(:group).permit( + :id, + :name, + :path, + :visibility_level, + :organization_id + ).with_defaults(organization_id: Current.organization.id) + end + + def project_params + params.require(:project).permit( + :initialize_with_readme, + :name, + :namespace_id, + :path, + :template_name, + :visibility_level + ) + end + end + end +end diff --git a/app/controllers/sessions_controller.rb b/app/controllers/sessions_controller.rb index 1fd3999f1c1e447f950895bc58344e6ad270b732..71fe61fbc3c20d93af509a2a9ac0512e4a6478ec 100644 --- a/app/controllers/sessions_controller.rb +++ b/app/controllers/sessions_controller.rb @@ -36,6 +36,7 @@ class SessionsController < Devise::SessionsController before_action :save_failed_login, if: :action_new_and_failed_login? before_action :load_recaptcha before_action :set_invite_params, only: [:new] + before_action :set_first_sign_in_cookie_before_redirect, only: [:create] after_action :log_failed_login, if: :action_new_and_failed_login? after_action :verify_known_sign_in, only: [:create] @@ -59,6 +60,7 @@ class SessionsController < Devise::SessionsController CAPTCHA_HEADER = 'X-GitLab-Show-Login-Captcha' MAX_FAILED_LOGIN_ATTEMPTS = 5 PRESERVE_COOKIES = %w[current_signin_tab preferred_language].freeze + FIRST_SIGN_IN_COOKIE = 'first_sign_in' def new set_minimum_password_length @@ -360,6 +362,48 @@ def set_invite_params # overridden by EE module def onboarding_status_tracking_label; end + + override :after_sign_in_path_for + + def after_sign_in_path_for(resource) + if should_show_self_managed_project_onboarding?(resource) + cookies.delete(FIRST_SIGN_IN_COOKIE) + new_admin_sign_up_group_path + else + super + end + end + + def should_show_self_managed_project_onboarding?(user) + return false unless user.admin? + return false unless self_managed? + return false unless first_sign_in_completed? + return false unless user.sign_in_count == 2 + return false unless User.human.one? + return false if Group.any? + + true + end + + def set_first_sign_in_cookie(_resource) + return if cookies[FIRST_SIGN_IN_COOKIE].present? + + cookies[FIRST_SIGN_IN_COOKIE] = 'true' + end + + def self_managed? + true + end + + def first_sign_in_completed? + cookies[FIRST_SIGN_IN_COOKIE].present? + end + + def set_first_sign_in_cookie_before_redirect + return unless request.post? && warden.authenticated?(:user) + + set_first_sign_in_cookie(warden.user) + end end SessionsController.prepend_mod_with('SessionsController') diff --git a/app/services/onboarding/self_managed/standard_namespace_create_service.rb b/app/services/onboarding/self_managed/standard_namespace_create_service.rb new file mode 100644 index 0000000000000000000000000000000000000000..15ca667b2acdf30db89d9a5e2e205613fafddff8 --- /dev/null +++ b/app/services/onboarding/self_managed/standard_namespace_create_service.rb @@ -0,0 +1,98 @@ +# frozen_string_literal: true + +module Onboarding + module SelfManaged + class StandardNamespaceCreateService + include BaseServiceUtility + + def initialize(user, group_params:, project_params:) + @current_user = user + @group_params = group_params.dup + @project_params = project_params.dup + end + + def execute + normalize_group_path + + group = find_or_create_group + return error_response(group: group) unless group.persisted? + + project = create_project(group) + return error_response(group: group, project: project) unless project.persisted? + + ServiceResponse.success(payload: { project: project, group: project.namespace }) + end + + private + + attr_reader :current_user, :group_params, :project_params + + def normalize_group_path + return if group_params[:path].present? + return unless group_params[:name].present? + + parameterized_path = group_params[:name].parameterize + group_params[:path] = parameterized_path.presence || SecureRandom.hex(4) + end + + def find_or_create_group + if group_params[:id].present? + Group.find(group_params[:id]) + else + create_group + end + rescue ActiveRecord::RecordNotFound + Group.new + end + + def create_group + filtered_params = group_params.dup + filtered_params.delete(:organization_id) if filtered_params[:organization_id].nil? + + result = Groups::CreateService.new(current_user, filtered_params).execute + + result.payload[:group] + end + + def create_project(group) + merged_params = project_params.dup + merged_params[:namespace_id] = group.id + merged_params[:organization_id] = group.organization_id if group.organization_id.present? + + Projects::CreateService.new(current_user, merged_params).execute + end + + def error_response(group: nil, project: nil) + group ||= Group.new(group_params) + filtered_project_params = project_params.except(:initialize_with_readme) + project ||= Project.new(filtered_project_params.merge(namespace: group)) + + ServiceResponse.error( + message: build_error_message(group, project), + payload: { group: group, project: project } + ) + end + + # @param group [Group, nil] The group object to validate + # @param project [Project, nil] The project object to validate + # @return [String] Error message containing validation errors or default message + def build_error_message(group, project) + return 'Group or project has errors' if group.nil? || project.nil? + + errors = [] + + if group.name.blank? || group.path.blank? + group.validate + errors.concat(group.errors.full_messages) if group.errors.any? + end + + if project.name.blank? || project.path.blank? + project.validate + errors.concat(project.errors.full_messages) if project.errors.any? + end + + errors.any? ? errors.join(', ') : 'Group or project has errors' + end + end + end +end diff --git a/app/views/admin/registrations/groups/new.html.haml b/app/views/admin/registrations/groups/new.html.haml new file mode 100644 index 0000000000000000000000000000000000000000..188e9c18ab404db4422b5e523de5f22cc805219e --- /dev/null +++ b/app/views/admin/registrations/groups/new.html.haml @@ -0,0 +1,37 @@ +- @hide_flash = true +- page_title _('Your GitLab group') +- add_page_specific_style 'page_bundles/registrations' + +.row.gl-grow + .gl-flex.gl-flex-col.gl-items-center.gl-w-full.gl-px-5.gl-pb-5 + .new-project.gl-flex.gl-flex-col.gl-items-center.gl-w-full{ class: "@sm/panel:gl-w-auto" } + %h2.gl-text-center= _('Create your first project') + + %p.gl-text-center= _('Projects help you organize your work. They contain your file repository, issues, merge requests, and so much more.') + + .js-toggle-container.gl-w-full + .tab-content.gitlab-tab-content.gl-bg-default.js-group-project-tab-contents + #blank-project-pane.tab-pane.js-toggle-container.active{ role: 'tabpanel' } + = gitlab_ui_form_for :project_group, + url: admin_sign_up_groups_path, + html: { class: 'gl-show-field-errors gl-w-full gl-p-4 js-groups-projects-form' } do |f| + = form_errors(@group, type: "Group") + = form_errors(@project, type: "Project") + = render 'layouts/flash' + + .js-create-group-project-fields{ data: { + import_group: 'false', + group_persisted: @group.persisted?.to_s, + group_id: @group.id, + group_name: @group.name, + project_name: @project.name, + template_name: @template_name, + initialize_with_readme: @initialize_with_readme.to_s, + root_url: root_url, + track_action_for_errors: '' } } + + .gl-flex.gl-justify-end.gl-gap-3 + = render Pajamas::ButtonComponent.new(href: home_dashboard_path, variant: :default, button_options: { data: { testid: 'skip-button' }}) do + = _("Skip") + = render Pajamas::ButtonComponent.new(type: :submit, variant: :confirm, button_options: { data: { testid: 'submit-button' }}) do + = _("Continue") diff --git a/config/routes/admin.rb b/config/routes/admin.rb index 6edba232c43da5cd3001c953c6d767a438d9f77d..627b260935be372d568e9b69a50ecff1ca2be91e 100644 --- a/config/routes/admin.rb +++ b/config/routes/admin.rb @@ -32,6 +32,10 @@ end end + namespace :sign_up do + resources :groups, only: [:new, :create], controller: '/admin/registrations/groups' + end + resource :session, only: [:new, :create] do post 'destroy', action: :destroy, as: :destroy end diff --git a/ee/app/controllers/ee/sessions_controller.rb b/ee/app/controllers/ee/sessions_controller.rb index 6ef9115e495b0af3bc4d24c94be2ad3410f34ef2..a0b62d97d03148c5c07eb0598bc9353088febc3c 100644 --- a/ee/app/controllers/ee/sessions_controller.rb +++ b/ee/app/controllers/ee/sessions_controller.rb @@ -28,6 +28,11 @@ def new end end + override :self_managed? + def self_managed? + !::Gitlab::Saas.feature_available?(:onboarding) + end + private def gitlab_geo_logout @@ -90,14 +95,24 @@ def detect_and_notify_for_compromised_password end override :onboarding_status_tracking_label + def onboarding_status_tracking_label onboarding_status_presenter.preregistration_tracking_label end + override :should_show_self_managed_project_onboarding? + + def should_show_self_managed_project_onboarding?(user) + return false if ::Gitlab::Saas.feature_available?(:onboarding) + + super + end + def onboarding_status_presenter ::Onboarding::StatusPresenter .new(params.permit(:invite_email).to_h.deep_symbolize_keys, session['user_return_to'], resource) end + strong_memoize_attr :onboarding_status_presenter end end diff --git a/ee/app/models/onboarding.rb b/ee/app/models/onboarding.rb index 3714cd3211c163ea136c852b67c72cbe3b833a6d..e4c6ffb5ec9ff1597c405d4f354843f45d9626fe 100644 --- a/ee/app/models/onboarding.rb +++ b/ee/app/models/onboarding.rb @@ -14,6 +14,10 @@ def self.enabled? ::Gitlab::Saas.feature_available?(:onboarding) end + def self.self_managed? + !::Gitlab::Saas.feature_available?(:onboarding) + end + def self.user_onboarding_in_progress?(user, use_cache: false) return false unless user.present? return false unless enabled? diff --git a/ee/spec/models/onboarding_spec.rb b/ee/spec/models/onboarding_spec.rb index cb0dcdc3ec002a69b7047e5090b1404ab995ca17..12e6dda72448f2fc50f2142bcfe5c23fe785184b 100644 --- a/ee/spec/models/onboarding_spec.rb +++ b/ee/spec/models/onboarding_spec.rb @@ -144,6 +144,42 @@ end end + describe '.self_managed?' do + subject { described_class.self_managed? } + + context 'when onboarding feature is available' do + before do + stub_saas_features(onboarding: true) + end + + it { is_expected.to eq(false) } + end + + context 'when onboarding feature is not available' do + before do + stub_saas_features(onboarding: false) + end + + it { is_expected.to eq(true) } + end + + context 'when Gitlab::Saas.feature_available? returns false' do + before do + allow(::Gitlab::Saas).to receive(:feature_available?).with(:onboarding).and_return(false) + end + + it { is_expected.to eq(true) } + end + + context 'when Gitlab::Saas.feature_available? returns true' do + before do + allow(::Gitlab::Saas).to receive(:feature_available?).with(:onboarding).and_return(true) + end + + it { is_expected.to eq(false) } + end + end + describe '.add_on_seat_assignment_iterable_params' do let(:namespace) { build(:namespace, id: non_existing_record_id) } diff --git a/ee/spec/views/registrations/groups/new.html.haml_spec.rb b/ee/spec/views/registrations/groups/new.html.haml_spec.rb index 14b9fb548d44a7d7f3636dbc5de6f7dec0d09531..2c12c366ecda4cd2930eefa8b324ce7640569cb8 100644 --- a/ee/spec/views/registrations/groups/new.html.haml_spec.rb +++ b/ee/spec/views/registrations/groups/new.html.haml_spec.rb @@ -70,6 +70,12 @@ expect(rendered).to have_css('#blank-project-pane') expect(rendered).to have_css('#import-project-pane') end + + it 'has submit button with Create project text' do + render + + expect(rendered).to have_button('Create project') + end end context 'with trial_registration_hierarchy_education_experiment experiment' do diff --git a/locale/gitlab.pot b/locale/gitlab.pot index 0b5a772fb9103261be01c2003d3ed9c8464ea4ef..98ebd01edcf1cf2e873ed751589ba61690c0dfff 100644 --- a/locale/gitlab.pot +++ b/locale/gitlab.pot @@ -20552,6 +20552,9 @@ msgstr "" msgid "Create your first page" msgstr "" +msgid "Create your first project" +msgstr "" + msgid "Create, update, or delete a merge request." msgstr "" @@ -64473,6 +64476,9 @@ msgstr "" msgid "Size limit per repository (MiB)" msgstr "" +msgid "Skip" +msgstr "" + msgid "Skip to input" msgstr "" diff --git a/spec/controllers/sessions_controller_spec.rb b/spec/controllers/sessions_controller_spec.rb index 1ee87c2309f32e76b30d5e0e39a292169a2dd5df..b166ed76a17d9428c3f5cad1a227732f4b2bc644 100644 --- a/spec/controllers/sessions_controller_spec.rb +++ b/spec/controllers/sessions_controller_spec.rb @@ -16,7 +16,7 @@ before do stub_omniauth_setting(auto_sign_in_with_provider: :saml) allow(controller).to receive(:omniauth_authorize_path).with(:user, :saml) - .and_return('/saml') + .and_return('/saml') end context 'and no auto_sign_in param is passed' do @@ -264,7 +264,7 @@ it 'creates audit event records' do expect { post(:create, params: { user: user_params }) }.to change { AuditEvent.count }.by(1) - .and change { AuditEvents::UserAuditEvent.count }.by(1) + .and change { AuditEvents::UserAuditEvent.count }.by(1) audit_event = AuditEvent.last expect(audit_event.details[:with]).to eq('standard') @@ -344,8 +344,8 @@ def unsuccessful_login(user_params, sesion_params: {}) expect(counter).to receive(:increment) expect(Gitlab::Metrics).to receive(:counter) - .with(:failed_login_captcha_total, anything) - .and_return(counter) + .with(:failed_login_captcha_total, anything) + .and_return(counter) post(:create, params: { user: user_params }, session: sesion_params) end @@ -357,8 +357,8 @@ def successful_login(user_params, sesion_params: {}) expect(counter).to receive(:increment) expect(Gitlab::Metrics).to receive(:counter) - .with(:successful_login_captcha_total, anything) - .and_return(counter) + .with(:successful_login_captcha_total, anything) + .and_return(counter) expect(Gitlab::Metrics).to receive(:counter).at_least(1).time.and_call_original post(:create, params: { user: user_params }, session: sesion_params) @@ -571,7 +571,7 @@ def authenticate_2fa(otp_user_id: user.id, **user_params) authenticate_2fa(otp_attempt: code) expect(controller).to set_flash.now[:alert] - .to(/Invalid two-factor code/) + .to(/Invalid two-factor code/) expect(@request.env['warden']).not_to be_authenticated end @@ -665,38 +665,38 @@ def authenticate_2fa(otp_user_id: user.id, **user_params) expect(session[:otp_user_id]).to be_nil end end + end + + context 'when another user does not have 2FA enabled' do + let(:another_user) { create(:user) } + + it "does not authenticate", :aggregate_failures do + authenticate_2fa(login: another_user.username, otp_attempt: 'invalid') + + expect(controller).to set_flash.now[:alert].to(/Invalid login or password/) + expect(@request.env['warden']).not_to be_authenticated + expect(subject.current_user).not_to eq another_user + end - context 'when another user does not have 2FA enabled' do - let(:another_user) { create(:user) } + context 'with username/password authentication is disabled' do + before do + stub_application_setting(password_authentication_enabled_for_web: false) + end it "does not authenticate", :aggregate_failures do authenticate_2fa(login: another_user.username, otp_attempt: 'invalid') - expect(controller).to set_flash.now[:alert].to(/Invalid login or password/) + expect(response).to have_gitlab_http_status(:forbidden) expect(@request.env['warden']).not_to be_authenticated expect(subject.current_user).not_to eq another_user end - - context 'with username/password authentication is disabled' do - before do - stub_application_setting(password_authentication_enabled_for_web: false) - end - - it "does not authenticate", :aggregate_failures do - authenticate_2fa(login: another_user.username, otp_attempt: 'invalid') - - expect(response).to have_gitlab_http_status(:forbidden) - expect(@request.env['warden']).not_to be_authenticated - expect(subject.current_user).not_to eq another_user - end - end end end end it 'creates audit event records' do expect { authenticate_2fa(login: user.username, otp_attempt: user.current_otp) }.to change { AuditEvent.count }.by(1) - .and change { AuditEvents::UserAuditEvent.count }.by(1) + .and change { AuditEvents::UserAuditEvent.count }.by(1) audit_event = AuditEvent.last expect(audit_event.details[:with]).to eq('two-factor') @@ -776,7 +776,7 @@ def authenticate_2fa(user_params) end expect { authenticate_2fa(login: user.username, device_response: "{}") }.to change { AuditEvent.count }.by(1) - .and change { AuditEvents::UserAuditEvent.count }.by(1) + .and change { AuditEvents::UserAuditEvent.count }.by(1) audit_event = AuditEvent.last expect(audit_event.details[:with]).to eq('two-factor-via-webauthn-device') @@ -940,6 +940,263 @@ def authenticate_2fa_with_passkeys end end + describe '#after_sign_in_path_for' do + let(:user) { create(:user) } + + subject(:after_sign_in_path) { controller.send(:after_sign_in_path_for, user) } + + context 'when user should see first project onboarding' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(true) + allow(Group).to receive(:any?).and_return(false) + admin_user.update_column(:sign_in_count, 2) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + request.cookies[SessionsController::FIRST_SIGN_IN_COOKIE] = 'true' + end + + it 'redirects to new admin sign up group path' do + expect(controller.send(:after_sign_in_path_for, admin_user)).to eq(new_admin_sign_up_group_path) + end + end + + context 'when user should not see first project onboarding' do + it 'calls super for normal redirect flow' do + expect(after_sign_in_path).not_to eq(new_admin_sign_up_group_path) + end + end + end + + describe '#should_show_self_managed_project_onboarding?' do + subject(:should_show_onboarding) do + controller.send(:should_show_self_managed_project_onboarding?, test_user) + end + + let(:test_user) { create(:user) } + + context 'when all conditions are met' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(true) + allow(Group).to receive(:any?).and_return(false) + admin_user.update_column(:sign_in_count, 2) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + request.cookies[SessionsController::FIRST_SIGN_IN_COOKIE] = 'true' + end + + it { is_expected.to be true } + end + + context 'when user is not an admin' do + let(:regular_user) { create(:user, sign_in_count: 1) } + let(:test_user) { regular_user } + + it { is_expected.to be false } + end + + context 'when self_managed? returns false' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + + before do + allow(controller).to receive(:self_managed?).and_return(false) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + end + + it { is_expected.to be false } + end + + context 'when first_sign_in_completed? returns false' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + + before do + allow(controller).to receive(:first_sign_in_completed?).and_return(false) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + end + + it { is_expected.to be false } + end + + context 'when sign_in_count is not 2' do + let(:admin_user) { create(:admin, sign_in_count: 3) } + let(:test_user) { admin_user } + + it { is_expected.to be false } + end + + context 'when sign_in_count is 1' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + + it { is_expected.to be false } + end + + context 'when there are multiple human users' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + let(:other_user) { create(:user) } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(false) + admin_user.update_column(:sign_in_count, 2) + other_user + end + + it { is_expected.to be false } + end + + context 'when User.human.one? returns false' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(false) + allow(Group).to receive(:any?).and_return(false) + admin_user.update_column(:sign_in_count, 2) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + request.cookies[SessionsController::FIRST_SIGN_IN_COOKIE] = 'true' + end + + it { is_expected.to be false } + end + + context 'when Group.any? returns true' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(true) + allow(Group).to receive(:any?).and_return(true) + admin_user.update_column(:sign_in_count, 2) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + request.cookies[SessionsController::FIRST_SIGN_IN_COOKIE] = 'true' + end + + it { is_expected.to be false } + end + + context 'when user already owns groups' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + let(:group) { create(:group) } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(true) + admin_user.update_column(:sign_in_count, 2) + group.add_owner(admin_user) + end + + it { is_expected.to be false } + end + + context 'when there are internal users but only one human user' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + let(:test_user) { admin_user } + let(:ghost_user) { create(:user, :ghost) } + let(:bot_user) { create(:user, :project_bot) } + + before do + ghost_user + bot_user + allow(User).to receive_message_chain(:human, :one?).and_return(true) + allow(Group).to receive(:any?).and_return(false) + admin_user.update_column(:sign_in_count, 2) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + request.cookies[SessionsController::FIRST_SIGN_IN_COOKIE] = 'true' + end + + it { is_expected.to be true } + end + + context 'when all conditions are met but User.human.one? is false' do + let(:admin_user) { create(:admin, sign_in_count: 2) } + let(:test_user) { admin_user } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(false) + allow(Group).to receive(:any?).and_return(false) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + request.cookies[SessionsController::FIRST_SIGN_IN_COOKIE] = 'true' + end + + it { is_expected.to be false } + end + + context 'when all conditions are met but Group.any? is true' do + let(:admin_user) { create(:admin, sign_in_count: 2) } + let(:test_user) { admin_user } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(true) + allow(Group).to receive(:any?).and_return(true) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + request.cookies[SessionsController::FIRST_SIGN_IN_COOKIE] = 'true' + end + + it { is_expected.to be false } + end + end + + describe '#self_managed?' do + it 'returns true' do + expect(controller.send(:self_managed?)).to be true + end + + it 'always returns true for self-managed instances' do + expect(controller.send(:self_managed?)).to eq(true) + end + + context 'when called multiple times' do + it 'consistently returns true' do + result1 = controller.send(:self_managed?) + result2 = controller.send(:self_managed?) + + expect(result1).to be true + expect(result2).to be true + end + end + end + + describe 'first-time root user login integration' do + let(:admin_user) { create(:admin, sign_in_count: 1) } + + before do + allow(User).to receive_message_chain(:human, :one?).and_return(true) + allow(admin_user).to receive_message_chain(:owned_groups, :any?).and_return(false) + allow(Gitlab::Auth::CurrentUserMode).to receive(:new).with(admin_user).and_return(instance_double(Gitlab::Auth::CurrentUserMode, admin_mode?: true)) + end + + context 'when first-time root user logs in' do + it 'redirects to new admin sign up group path' do + post :create, params: { user: { login: admin_user.username, password: admin_user.password } } + + expect(response).to redirect_to(new_admin_sign_up_group_path) + end + + it 'increments sign_in_count to 2' do + expect do + post :create, params: { user: { login: admin_user.username, password: admin_user.password } } + end.to change { admin_user.reload.sign_in_count }.from(1).to(2) + end + end + + context 'when user logs in third time' do + before do + admin_user.update_column(:sign_in_count, 2) + end + + it 'does not redirect to new admin sign up group path' do + post :create, params: { user: { login: admin_user.username, password: admin_user.password } } + + expect(response).not_to redirect_to(new_admin_sign_up_group_path) + end + end + end + context 'when login fails' do before do @request.env["warden.options"] = { action: 'unauthenticated' } diff --git a/spec/requests/admin/registrations/groups_controller_spec.rb b/spec/requests/admin/registrations/groups_controller_spec.rb new file mode 100644 index 0000000000000000000000000000000000000000..3c3c9afcc0b40e0d28d18e95a9fed50c2b9e4500 --- /dev/null +++ b/spec/requests/admin/registrations/groups_controller_spec.rb @@ -0,0 +1,269 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe 'Admin::Registrations::GroupsController', :with_current_organization, feature_category: :onboarding do + include AdminModeHelper + + let_it_be(:user, reload: true) { create(:admin) } + let_it_be(:group) { create(:group) } + + describe 'GET /admin/sign_up/groups/new' do + subject(:get_new) { get new_admin_sign_up_group_path } + + context 'with an unauthenticated user' do + it 'redirects to sign in' do + get_new + + expect(response).to have_gitlab_http_status(:redirect) + expect(response).to redirect_to(new_user_session_path) + end + end + + context 'with an authenticated admin user' do + before do + sign_in(user) + enable_admin_mode!(user) + end + + it 'returns success' do + get_new + + expect(response).to have_gitlab_http_status(:ok) + end + + it 'renders the new template' do + get_new + + expect(response.body).to include('Create your first project') + expect(response.body).to include('js-create-group-project-fields') + end + + context 'when user is not an admin' do + let(:non_admin_user) { create(:user) } + + before do + sign_out(user) + sign_in(non_admin_user) + end + + it 'returns not found' do + get_new + + expect(response).to have_gitlab_http_status(:not_found) + end + end + + context 'when user is not an admin on POST' do + let(:non_admin_user) { create(:user) } + + before do + sign_out(user) + sign_in(non_admin_user) + end + + it 'returns not found' do + post admin_sign_up_groups_path, params: { group: { name: 'test' }, project: { name: 'test' } } + + expect(response).to have_gitlab_http_status(:not_found) + end + end + end + end + + describe 'POST /admin/sign_up/groups' do + subject(:post_create) { post admin_sign_up_groups_path, params: params } + + let(:params) { { group: group_params, project: project_params } } + let(:group_params) do + { + name: 'Group name', + path: 'group-path', + visibility_level: Gitlab::VisibilityLevel::PRIVATE.to_s + } + end + + let(:project_params) do + { + name: 'New project', + path: 'project-path', + visibility_level: Gitlab::VisibilityLevel::PRIVATE, + initialize_with_readme: 'true' + } + end + + context 'with an unauthenticated user' do + it 'redirects to sign in' do + post_create + + expect(response).to have_gitlab_http_status(:redirect) + expect(response).to redirect_to(new_user_session_path) + end + end + + context 'with an authenticated admin user' do + before do + sign_in(user) + enable_admin_mode!(user) + end + + it 'creates a group and project' do + expect { post_create }.to change { Group.count }.by(1).and change { Project.count }.by(1) + end + + it 'redirects to the created project' do + post_create + + expect(response).to have_gitlab_http_status(:redirect) + expect(response).to redirect_to(project_path(Project.last)) + end + + context 'when user has no existing groups or projects' do + let(:new_admin) { create(:admin) } + + before do + sign_out(user) + sign_in(new_admin) + enable_admin_mode!(new_admin) + end + + it 'creates the first group and project' do + expect(new_admin.owned_groups).to be_empty + expect(new_admin.projects).to be_empty + + expect { post_create }.to change { Group.count }.by(1).and change { Project.count }.by(1) + + expect(new_admin.reload.owned_groups.count).to eq(1) + end + end + + context 'when there is no suggested path based from the name' do + let(:group_params) { { name: '⛄⛄⛄', path: '' } } + + it 'creates a group' do + expect { post_create }.to change { Group.count }.by(1) + end + end + + context 'when the group cannot be created' do + let(:group_params) { { name: '', path: '' } } + + it 'does not create a group' do + expect { post_create }.not_to change { Group.count } + end + + it 'returns success and re-renders the form' do + post_create + + expect(response).to have_gitlab_http_status(:ok) + expect(response.body).to include('Create your first project') + end + + it 'displays error messages' do + post_create + + expect(response.body).to include('Group') + end + end + + context "when group can be created but the project can't" do + let(:project_params) { { name: '', path: '', visibility_level: Gitlab::VisibilityLevel::PRIVATE } } + + it 'does not create a project' do + expect { post_create }.to change { Group.count }.and not_change { Project.count } + end + + it 'returns success and re-renders the form' do + post_create + + expect(response).to have_gitlab_http_status(:ok) + expect(response.body).to include('Create your first project') + end + + it 'displays error messages' do + post_create + + expect(response.body).to include('Project') + end + end + + context "when a group is already created but a project isn't" do + before_all do + group.add_owner(user) + end + + let(:group_params) { { id: group.id } } + + it 'creates a project and not another group' do + expect { post_create }.to change { Project.count }.and not_change { Group.count } + end + end + + context 'when redirecting' do + let_it_be(:project) { create(:project) } + + let(:success_path) { project_path(project) } + + before do + allow_next_instance_of(Onboarding::SelfManaged::StandardNamespaceCreateService) do |service| + allow(service).to receive(:execute).and_return( + ServiceResponse.success(payload: { project: project }) + ) + end + end + + it 'redirects to the project path' do + post_create + + expect(response).to redirect_to(success_path) + end + end + + context 'with template_name in the params' do + let(:project_params) { super().merge(template_name: 'plainhtml') } + + it 'includes template_name in the re-rendered form' do + allow_next_instance_of(Onboarding::SelfManaged::StandardNamespaceCreateService) do |service| + allow(service).to receive(:execute).and_return( + ServiceResponse.error(message: 'failed', payload: { group: Group.new, project: Project.new }) + ) + end + + post_create + + expect(response.body).to include('data-template-name="plainhtml"') + end + end + + context 'with initialize_with_readme in the params' do + let(:project_params) { super().merge(initialize_with_readme: 'false') } + + it 'includes initialize_with_readme in the re-rendered form' do + allow_next_instance_of(Onboarding::SelfManaged::StandardNamespaceCreateService) do |service| + allow(service).to receive(:execute).and_return( + ServiceResponse.error(message: 'failed', payload: { group: Group.new, project: Project.new }) + ) + end + + post_create + + expect(response.body).to include('data-initialize-with-readme="false"') + end + end + end + + context 'with a non-admin user' do + let(:non_admin_user) { create(:user) } + + before do + sign_in(non_admin_user) + end + + it 'returns not found' do + post_create + + expect(response).to have_gitlab_http_status(:not_found) + end + end + end +end diff --git a/spec/services/onboarding/self_managed/standard_namespace_create_service_spec.rb b/spec/services/onboarding/self_managed/standard_namespace_create_service_spec.rb new file mode 100644 index 0000000000000000000000000000000000000000..916be024490258c80177dc7a632af806f58a2ba0 --- /dev/null +++ b/spec/services/onboarding/self_managed/standard_namespace_create_service_spec.rb @@ -0,0 +1,416 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Onboarding::SelfManaged::StandardNamespaceCreateService, :aggregate_failures, feature_category: :onboarding do + describe '#execute' do + let_it_be(:user) { create(:user, can_create_group: true) } + let_it_be(:organization) { create(:organization, users: [user]) } + + let(:group_params) do + { + name: 'Group name', + path: 'group-path', + visibility_level: Gitlab::VisibilityLevel::PRIVATE, + organization_id: organization.id + } + end + + let(:extra_project_params) { {} } + let(:project_params) do + { + name: 'New project', + path: 'project-path', + visibility_level: Gitlab::VisibilityLevel::PRIVATE, + initialize_with_readme: true + }.merge(extra_project_params) + end + + subject(:execute) do + described_class + .new(user, group_params: group_params, project_params: project_params).execute + end + + context 'when group and project can be created' do + it 'creates a group and project' do + expect { execute }.to change { Group.count }.by(1) + .and change { Project.count }.by(1) + end + + it 'returns the created project in the payload' do + result = execute + + expect(result).to be_success + expect(result.payload[:project]).to be_persisted + expect(result.payload[:project].namespace).to be_a(Group) + end + + it 'sets the correct organization_id on the project' do + result = execute + + expect(result.payload[:project].organization_id).to eq(organization.id) + end + + it 'allows for the project to be initialized with a README' do + create_params = project_params.merge( + organization_id: organization.id, + namespace_id: anything + ) + expect(::Projects::CreateService).to receive(:new).with(user, create_params).and_call_original + + expect(execute).to be_success + end + end + + context 'when the group cannot be created' do + let(:group_params) { { name: '', path: '', organization_id: organization.id } } + + it 'does not create a group' do + expect { execute }.not_to change { Group.count } + expect(execute).to be_error + expect(execute.payload[:group].errors).not_to be_blank + end + + it 'returns both group and project in the error payload' do + result = execute + + expect(result).to be_error + expect(result.payload[:group]).not_to be_persisted + expect(result.payload[:project]).not_to be_persisted + expect(result.payload[:project].name).to eq('New project') + end + + it 'does not create a project' do + expect { execute }.not_to change { Project.count } + end + end + + context 'when group can be created but not the project' do + let(:project_params) do + { + name: '', + path: '', + visibility_level: Gitlab::VisibilityLevel::PRIVATE + } + end + + it 'does not create a project' do + expect { execute }.to change { Group.count }.by(1) + .and not_change { Project.count } + + expect(execute).to be_error + expect(execute.payload[:project].errors).not_to be_blank + end + + it 'returns the created group and failed project in the payload' do + result = execute + + expect(result).to be_error + expect(result.payload[:group]).to be_persisted + expect(result.payload[:project]).not_to be_persisted + end + end + + context 'when a group already exists and project needs to be created' do + let_it_be(:existing_group) do + group = create(:group, organization: organization) + group.add_member(user, Gitlab::Access::OWNER) + group + end + + let(:group_params) { { id: existing_group.id } } + + it 'creates a project and not another group' do + group_count = Group.count + + expect { execute }.to change { Project.count }.by(1) + + expect(Group.count).to eq(group_count) + end + + it 'creates the project in the existing group' do + result = execute + + expect(result).to be_success + expect(result.payload[:project].namespace).to eq(existing_group) + end + end + + context 'when group path is blank but name is present' do + let(:group_params) do + { + name: 'My Test Group', + path: '', + visibility_level: Gitlab::VisibilityLevel::PRIVATE, + organization_id: organization.id + } + end + + it 'normalizes the group path from the name' do + result = execute + + expect(result).to be_success + expect(result.payload[:project].namespace.path).to eq('my-test-group') + end + end + + context 'when user cannot create groups' do + let(:user) { create(:user, can_create_group: false) } + + it 'returns an error response' do + result = execute + + expect(result).to be_error + expect(result.payload[:group]).not_to be_persisted + expect(result.payload[:project]).not_to be_persisted + end + end + + context 'when group_params has invalid id' do + let(:group_params) { { id: non_existing_record_id } } + + it 'returns an error response' do + result = execute + + expect(result).to be_error + expect(result.payload[:group]).not_to be_persisted + expect(result.payload[:project]).not_to be_persisted + end + end + + context 'with initialize_with_readme option' do + let(:group_params) do + { + name: 'Test Group README', + path: 'test-group-readme', + visibility_level: Gitlab::VisibilityLevel::PRIVATE, + organization_id: organization.id + } + end + + let(:project_params) do + { + name: 'Test Project', + path: 'test-project', + initialize_with_readme: true, + visibility_level: Gitlab::VisibilityLevel::PRIVATE + } + end + + it 'creates project with README' do + result = execute + + expect(result).to be_success + expect(result.payload[:project].repository.readme).to be_present + end + end + + context 'when group organization_id is nil' do + let(:group_params) do + { + name: 'Test Group', + path: 'test-group', + visibility_level: Gitlab::VisibilityLevel::PRIVATE, + organization_id: nil + } + end + + it 'does not set organization_id on the project' do + result = execute + + expect(result).to be_error + expect(result.payload[:group].errors[:organization]).to be_present + end + end + + context 'when group organization_id is present' do + let(:group_params) do + { + name: 'Test Group', + path: 'test-group', + visibility_level: Gitlab::VisibilityLevel::PRIVATE, + organization_id: organization.id + } + end + + it 'sets organization_id on the project' do + result = execute + + expect(result).to be_success + expect(result.payload[:project].organization_id).to eq(organization.id) + end + end + end + + describe '#build_error_message' do + let(:user) { create(:user, can_create_group: true) } + let(:organization) { create(:organization, users: [user]) } + let(:service) do + described_class.new(user, group_params: {}, project_params: {}) + end + + context 'when group has errors' do + it 'includes group errors in the message' do + group = Group.new(name: '', path: '', organization_id: organization.id) + project = Project.new + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + end + + it 'includes multiple group errors' do + group = Group.new(name: '', path: '') + project = Project.new + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + expect(message).to include('Path') + end + end + + context 'when project has errors' do + it 'includes project errors in the message' do + group = Group.new(name: 'Test', path: 'test', organization_id: organization.id) + project = Project.new(name: '', path: '') + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + end + + it 'includes multiple project errors' do + group = Group.new(name: 'Test', path: 'test') + project = Project.new(name: '', path: '') + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + expect(message).to include('Path') + end + end + + context 'when both group and project have errors' do + it 'includes both group and project errors' do + group = Group.new(name: '', path: '', organization_id: organization.id) + project = Project.new(name: '', path: '') + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + expect(message).to include('Path') + end + end + + context 'when group.errors.any? returns true' do + it 'includes group errors in the message' do + group = Group.new(name: '', path: '', organization_id: organization.id) + project = Project.new(name: 'Valid', path: 'valid') + + message = service.send(:build_error_message, group, project) + + expect(message).not_to eq('Group or project has errors') + expect(message).to include('Name') + end + end + + context 'when project.errors.any? returns true' do + it 'includes project errors in the message' do + group = Group.new(name: 'Valid', path: 'valid', organization_id: organization.id) + project = Project.new(name: '', path: '') + + message = service.send(:build_error_message, group, project) + + expect(message).not_to eq('Group or project has errors') + expect(message).to include('Name') + end + end + + context 'when group is nil' do + it 'returns default message' do + project = Project.new + + message = service.send(:build_error_message, nil, project) + + expect(message).to eq('Group or project has errors') + end + end + + context 'when project is nil' do + it 'returns default message' do + group = Group.new + + message = service.send(:build_error_message, group, nil) + + expect(message).to eq('Group or project has errors') + end + end + + context 'when both group and project have no errors' do + it 'returns default message' do + group = Group.new(name: 'Test', path: 'test') + project = Project.new(name: 'Test', path: 'test') + + message = service.send(:build_error_message, group, project) + + expect(message).to eq('Group or project has errors') + end + end + + context 'when both group and project are nil' do + it 'returns default message' do + message = service.send(:build_error_message, nil, nil) + + expect(message).to eq('Group or project has errors') + end + end + + context 'when group is persisted but has blank name' do + it 'validates and includes errors' do + group = create(:group, name: 'Test', path: 'test', organization_id: organization.id) + group.update_column(:name, '') + project = Project.new + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + end + end + + context 'when project is persisted but has blank name' do + it 'validates and includes errors' do + group = create(:group, organization_id: organization.id) + project = create(:project, namespace: group, name: 'Test') + project.update_column(:name, '') + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + end + end + + context 'when group is persisted and has no blank fields' do + it 'does not include group errors' do + group = create(:group, organization_id: organization.id) + project = Project.new(name: '', path: '') + + message = service.send(:build_error_message, group, project) + + expect(message).to include('Name') + expect(message).not_to include(group.name) + end + end + + context 'when project is persisted and has no blank fields' do + it 'does not include project errors' do + group = create(:group, organization_id: organization.id) + project = create(:project, namespace: group) + + message = service.send(:build_error_message, group, project) + + expect(message).to eq('Group or project has errors') + end + end + end +end diff --git a/spec/views/admin/registrations/groups/new.html.haml_spec.rb b/spec/views/admin/registrations/groups/new.html.haml_spec.rb new file mode 100644 index 0000000000000000000000000000000000000000..a8062e2dc5ed4f8cec205291bf807054bcaf3b76 --- /dev/null +++ b/spec/views/admin/registrations/groups/new.html.haml_spec.rb @@ -0,0 +1,122 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe 'admin/registrations/groups/new', feature_category: :onboarding do + let(:user) { build_stubbed(:user) } + let(:group) { build_stubbed(:group) } + let(:project) { build_stubbed(:project) } + + before do + assign(:group, group) + assign(:project, project) + assign(:initialize_with_readme, true) + allow(view).to receive(:current_user).and_return(user) + end + + context 'for form action path' do + subject { render && rendered } + + it 'has the correct form action path' do + is_expected.to have_css('form[action="/admin/sign_up/groups"]') + end + end + + context 'with expected DOM elements' do + it 'contains js-groups-projects-form class' do + render + + expect(rendered).to have_css('.js-groups-projects-form') + end + + it 'has the create project heading' do + render + + expect(rendered).to have_css('h2', text: 'Create your first project') + end + + it 'has the project description text' do + render + + expect(rendered).to have_content('Projects help you organize your work') + end + + it 'has project creation form tabs' do + render + + expect(rendered).to have_css('.js-toggle-container') + expect(rendered).to have_css('#blank-project-pane') + end + + it 'has the submit button' do + render + + expect(rendered).to have_button('Continue') + end + + it 'has the skip button' do + render + + expect(rendered).to have_link('Skip', href: home_dashboard_path) + end + end + + context 'with js-create-group-project-fields data attributes' do + before do + render + end + + it 'sets the correct data attributes', :aggregate_failures do + expect(rendered).to have_css('.js-create-group-project-fields') + expect(rendered).to have_css("[data-import-group='false']") + expect(rendered).to have_css("[data-group-persisted='#{group.persisted?}']") + expect(rendered).to have_css("[data-group-id='#{group.id}']") + expect(rendered).to have_css("[data-group-name='#{group.name}']") + expect(rendered).to have_css("[data-project-name='#{project.name}']") + expect(rendered).to have_css("[data-initialize-with-readme='true']") + end + end + + context 'with template_name assigned' do + before do + assign(:template_name, 'rails') + render + end + + it 'sets the template_name data attribute' do + expect(rendered).to have_css("[data-template-name='rails']") + end + end + + context 'with flash messages' do + before do + allow(view).to receive(:flash).and_return({ notice: 'Test notice' }) + render + end + + it 'renders flash messages' do + expect(view).to render_template(partial: 'layouts/_flash') + end + end + + context 'with form errors' do + let(:group_with_errors) { build(:group, name: '') } + let(:project_with_errors) { build(:project, name: '') } + + before do + group_with_errors.valid? + project_with_errors.valid? + assign(:group, group_with_errors) + assign(:project, project_with_errors) + render + end + + it 'displays group errors' do + expect(rendered).to have_content("Group") + end + + it 'displays project errors' do + expect(rendered).to have_content("Project") + end + end +end