Welcome to mirror list, hosted at ThFree Co, Russian Federation.

gitlab.com/gitlab-org/gitlab-foss.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/spec/controllers/admin/serverless/domains_controller_spec.rb
diff options
context:
space:
mode:
Diffstat (limited to 'spec/controllers/admin/serverless/domains_controller_spec.rb')
-rw-r--r--spec/controllers/admin/serverless/domains_controller_spec.rb298
1 files changed, 298 insertions, 0 deletions
diff --git a/spec/controllers/admin/serverless/domains_controller_spec.rb b/spec/controllers/admin/serverless/domains_controller_spec.rb
new file mode 100644
index 00000000000..aed83e190be
--- /dev/null
+++ b/spec/controllers/admin/serverless/domains_controller_spec.rb
@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Admin::Serverless::DomainsController do
+ let(:admin) { create(:admin) }
+ let(:user) { create(:user) }
+
+ describe '#index' do
+ context 'non-admin user' do
+ before do
+ sign_in(user)
+ end
+
+ it 'responds with 404' do
+ get :index
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'admin user' do
+ before do
+ create(:pages_domain)
+ sign_in(admin)
+ end
+
+ context 'with serverless_domain feature disabled' do
+ before do
+ stub_feature_flags(serverless_domain: false)
+ end
+
+ it 'responds with 404' do
+ get :index
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'when instance-level serverless domain exists' do
+ let!(:serverless_domain) { create(:pages_domain, :instance_serverless) }
+
+ it 'loads the instance serverless domain' do
+ get :index
+
+ expect(assigns(:domain).id).to eq(serverless_domain.id)
+ end
+ end
+
+ context 'when domain does not exist' do
+ it 'initializes an instance serverless domain' do
+ get :index
+
+ domain = assigns(:domain)
+
+ expect(domain.persisted?).to eq(false)
+ expect(domain.wildcard).to eq(true)
+ expect(domain.scope).to eq('instance')
+ expect(domain.usage).to eq('serverless')
+ end
+ end
+ end
+ end
+
+ describe '#create' do
+ let(:create_params) do
+ sample_domain = build(:pages_domain)
+
+ {
+ domain: 'serverless.gitlab.io',
+ user_provided_certificate: sample_domain.certificate,
+ user_provided_key: sample_domain.key
+ }
+ end
+
+ context 'non-admin user' do
+ before do
+ sign_in(user)
+ end
+
+ it 'responds with 404' do
+ post :create, params: { pages_domain: create_params }
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'admin user' do
+ before do
+ sign_in(admin)
+ end
+
+ context 'with serverless_domain feature disabled' do
+ before do
+ stub_feature_flags(serverless_domain: false)
+ end
+
+ it 'responds with 404' do
+ post :create, params: { pages_domain: create_params }
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'when an instance-level serverless domain exists' do
+ let!(:serverless_domain) { create(:pages_domain, :instance_serverless) }
+
+ it 'does not create a new domain' do
+ expect { post :create, params: { pages_domain: create_params } }.not_to change { PagesDomain.instance_serverless.count }
+ end
+
+ it 'redirects to index' do
+ post :create, params: { pages_domain: create_params }
+
+ expect(response).to redirect_to admin_serverless_domains_path
+ expect(flash[:notice]).to include('An instance-level serverless domain already exists.')
+ end
+ end
+
+ context 'when an instance-level serverless domain does not exist' do
+ it 'creates an instance serverless domain with the provided attributes' do
+ expect { post :create, params: { pages_domain: create_params } }.to change { PagesDomain.instance_serverless.count }.by(1)
+
+ domain = PagesDomain.instance_serverless.first
+ expect(domain.domain).to eq(create_params[:domain])
+ expect(domain.certificate).to eq(create_params[:user_provided_certificate])
+ expect(domain.key).to eq(create_params[:user_provided_key])
+ expect(domain.wildcard).to eq(true)
+ expect(domain.scope).to eq('instance')
+ expect(domain.usage).to eq('serverless')
+ end
+
+ it 'redirects to index' do
+ post :create, params: { pages_domain: create_params }
+
+ expect(response).to redirect_to admin_serverless_domains_path
+ expect(flash[:notice]).to include('Domain was successfully created.')
+ end
+ end
+
+ context 'when there are errors' do
+ it 'renders index view' do
+ post :create, params: { pages_domain: { foo: 'bar' } }
+
+ expect(assigns(:domain).errors.size).to be > 0
+ expect(response).to render_template('index')
+ end
+ end
+ end
+ end
+
+ describe '#update' do
+ let(:domain) { create(:pages_domain, :instance_serverless) }
+
+ let(:update_params) do
+ sample_domain = build(:pages_domain)
+
+ {
+ user_provided_certificate: sample_domain.certificate,
+ user_provided_key: sample_domain.key
+ }
+ end
+
+ context 'non-admin user' do
+ before do
+ sign_in(user)
+ end
+
+ it 'responds with 404' do
+ put :update, params: { id: domain.id, pages_domain: update_params }
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'admin user' do
+ before do
+ sign_in(admin)
+ end
+
+ context 'with serverless_domain feature disabled' do
+ before do
+ stub_feature_flags(serverless_domain: false)
+ end
+
+ it 'responds with 404' do
+ put :update, params: { id: domain.id, pages_domain: update_params }
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'when domain exists' do
+ it 'updates the domain with the provided attributes' do
+ new_certificate = build(:pages_domain, :ecdsa).certificate
+ new_key = build(:pages_domain, :ecdsa).key
+
+ put :update, params: { id: domain.id, pages_domain: { user_provided_certificate: new_certificate, user_provided_key: new_key } }
+
+ domain.reload
+
+ expect(domain.certificate).to eq(new_certificate)
+ expect(domain.key).to eq(new_key)
+ end
+
+ it 'does not update the domain name' do
+ put :update, params: { id: domain.id, pages_domain: { domain: 'new.com' } }
+
+ expect(domain.reload.domain).not_to eq('new.com')
+ end
+
+ it 'redirects to index' do
+ put :update, params: { id: domain.id, pages_domain: update_params }
+
+ expect(response).to redirect_to admin_serverless_domains_path
+ expect(flash[:notice]).to include('Domain was successfully updated.')
+ end
+ end
+
+ context 'when domain does not exist' do
+ it 'returns 404' do
+ put :update, params: { id: 0, pages_domain: update_params }
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'when there are errors' do
+ it 'renders index view' do
+ put :update, params: { id: domain.id, pages_domain: { user_provided_certificate: 'bad certificate' } }
+
+ expect(assigns(:domain).errors.size).to be > 0
+ expect(response).to render_template('index')
+ end
+ end
+ end
+ end
+
+ describe '#verify' do
+ let(:domain) { create(:pages_domain, :instance_serverless) }
+
+ context 'non-admin user' do
+ before do
+ sign_in(user)
+ end
+
+ it 'responds with 404' do
+ post :verify, params: { id: domain.id }
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ context 'admin user' do
+ before do
+ sign_in(admin)
+ end
+
+ def stub_service
+ service = double(:service)
+
+ expect(VerifyPagesDomainService).to receive(:new).with(domain).and_return(service)
+
+ service
+ end
+
+ context 'with serverless_domain feature disabled' do
+ before do
+ stub_feature_flags(serverless_domain: false)
+ end
+
+ it 'responds with 404' do
+ post :verify, params: { id: domain.id }
+
+ expect(response.status).to eq(404)
+ end
+ end
+
+ it 'handles verification success' do
+ expect(stub_service).to receive(:execute).and_return(status: :success)
+
+ post :verify, params: { id: domain.id }
+
+ expect(response).to redirect_to admin_serverless_domains_path
+ expect(flash[:notice]).to eq('Successfully verified domain ownership')
+ end
+
+ it 'handles verification failure' do
+ expect(stub_service).to receive(:execute).and_return(status: :failed)
+
+ post :verify, params: { id: domain.id }
+
+ expect(response).to redirect_to admin_serverless_domains_path
+ expect(flash[:alert]).to eq('Failed to verify domain ownership')
+ end
+ end
+ end
+end
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-14 13:47:17 +0300