Add latest changes from gitlab-org/gitlab@master

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