Add latest changes from gitlab-org/gitlab@master

11 files changed, 473 insertions, 6 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
diff --git a/spec/features/admin/admin_serverless_domains_spec.rb b/spec/features/admin/admin_serverless_domains_spec.rb
new file mode 100644
index 00000000000..85fe67004da
--- /dev/null
+++ b/spec/features/admin/admin_serverless_domains_spec.rb
@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Admin Serverless Domains', :js do
+  let(:sample_domain) { build(:pages_domain) }
+
+  before do
+    allow(Gitlab.config.pages).to receive(:enabled).and_return(true)
+    sign_in(create(:admin))
+  end
+
+  it 'Add domain with certificate' do
+    visit admin_serverless_domains_path
+
+    fill_in 'pages_domain[domain]', with: 'foo.com'
+    fill_in 'pages_domain[user_provided_certificate]', with: sample_domain.certificate
+    fill_in 'pages_domain[user_provided_key]', with: sample_domain.key
+    click_button 'Add domain'
+
+    expect(current_path).to eq admin_serverless_domains_path
+
+    expect(page).to have_field('pages_domain[domain]', with: 'foo.com')
+    expect(page).to have_field('serverless_domain_dns', with: /^\*\.foo\.com CNAME /)
+    expect(page).to have_field('serverless_domain_verification', with: /^_gitlab-pages-verification-code.foo.com TXT /)
+    expect(page).not_to have_field('pages_domain[user_provided_certificate]')
+    expect(page).not_to have_field('pages_domain[user_provided_key]')
+
+    expect(page).to have_content 'Unverified'
+    expect(page).to have_content '/CN=test-certificate'
+  end
+
+  it 'Update domain certificate' do
+    visit admin_serverless_domains_path
+
+    fill_in 'pages_domain[domain]', with: 'foo.com'
+    fill_in 'pages_domain[user_provided_certificate]', with: sample_domain.certificate
+    fill_in 'pages_domain[user_provided_key]', with: sample_domain.key
+    click_button 'Add domain'
+
+    expect(current_path).to eq admin_serverless_domains_path
+
+    expect(page).not_to have_field('pages_domain[user_provided_certificate]')
+    expect(page).not_to have_field('pages_domain[user_provided_key]')
+
+    click_button 'Replace'
+
+    expect(page).to have_field('pages_domain[user_provided_certificate]')
+    expect(page).to have_field('pages_domain[user_provided_key]')
+
+    fill_in 'pages_domain[user_provided_certificate]', with: sample_domain.certificate
+    fill_in 'pages_domain[user_provided_key]', with: sample_domain.key
+
+    click_button 'Save changes'
+
+    expect(page).to have_content 'Domain was successfully updated'
+    expect(page).to have_content '/CN=test-certificate'
+  end
+end
diff --git a/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/metrics.json b/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/metrics.json
index ac40f2dcd13..038f5ac5d4e 100644
--- a/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/metrics.json
+++ b/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/metrics.json
@@ -16,7 +16,8 @@
     "label": { "type": "string" },
     "track": { "type": "string" },
     "prometheus_endpoint_path": { "type": "string" },
-    "metric_id": { "type": "number" }
+    "metric_id": { "type": "number" },
+    "edit_path": { "type": ["string", "null"] }
   },
   "additionalProperties": false
 }
diff --git a/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/panel_groups.json b/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/panel_groups.json
index f4afb4cbffc..d16fcd40359 100644
--- a/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/panel_groups.json
+++ b/spec/fixtures/lib/gitlab/metrics/dashboard/schemas/panel_groups.json
@@ -10,7 +10,8 @@
     "panels": {
       "type": "array",
       "items": { "$ref": "panels.json" }
-    }
+    },
+    "has_custom_metrics": { "type": "boolean" }
   },
   "additionalProperties": false
 }
diff --git a/spec/lib/gitlab/database_spec.rb b/spec/lib/gitlab/database_spec.rb
index 4a0eab3ea27..b99f311de29 100644
--- a/spec/lib/gitlab/database_spec.rb
+++ b/spec/lib/gitlab/database_spec.rb
@@ -394,6 +394,12 @@ describe Gitlab::Database do
         expect(described_class.cached_table_exists?(:bogus_table_name)).to be_falsey
       end
     end
+
+    it 'returns false when database does not exist' do
+      expect(ActiveRecord::Base).to receive(:connection) { raise ActiveRecord::NoDatabaseError, 'broken' }
+
+      expect(described_class.cached_table_exists?(:projects)).to be(false)
+    end
   end
 
   describe '.exists?' do
diff --git a/spec/lib/gitlab/gitaly_client/commit_service_spec.rb b/spec/lib/gitlab/gitaly_client/commit_service_spec.rb
index 5e1d6199c3c..5c36d6d35af 100644
--- a/spec/lib/gitlab/gitaly_client/commit_service_spec.rb
+++ b/spec/lib/gitlab/gitaly_client/commit_service_spec.rb
@@ -281,6 +281,19 @@ describe Gitlab::GitalyClient::CommitService do
   end
 
   describe '#find_commits' do
+    it 'sends an RPC request with NONE when default' do
+      request = Gitaly::FindCommitsRequest.new(
+        repository: repository_message,
+        disable_walk: true,
+        order: 'NONE'
+      )
+
+      expect_any_instance_of(Gitaly::CommitService::Stub).to receive(:find_commits)
+        .with(request, kind_of(Hash)).and_return([])
+
+      client.find_commits(order: 'default')
+    end
+
     it 'sends an RPC request' do
       request = Gitaly::FindCommitsRequest.new(
         repository: repository_message,
diff --git a/spec/lib/gitlab/metrics/dashboard/processor_spec.rb b/spec/lib/gitlab/metrics/dashboard/processor_spec.rb
index 8c3942c7f7d..e8860d50437 100644
--- a/spec/lib/gitlab/metrics/dashboard/processor_spec.rb
+++ b/spec/lib/gitlab/metrics/dashboard/processor_spec.rb
@@ -12,6 +12,7 @@ describe Gitlab::Metrics::Dashboard::Processor do
       [
         Gitlab::Metrics::Dashboard::Stages::CommonMetricsInserter,
         Gitlab::Metrics::Dashboard::Stages::ProjectMetricsInserter,
+        Gitlab::Metrics::Dashboard::Stages::ProjectMetricsDetailsInserter,
         Gitlab::Metrics::Dashboard::Stages::EndpointInserter,
         Gitlab::Metrics::Dashboard::Stages::Sorter
       ]
@@ -25,6 +26,10 @@ describe Gitlab::Metrics::Dashboard::Processor do
       end
     end
 
+    it 'includes boolean to indicate if panel group has custom metrics' do
+      expect(dashboard[:panel_groups]).to all(include( { has_custom_metrics: boolean } ))
+    end
+
     context 'when the dashboard is not present' do
       let(:dashboard_yml) { nil }
 
@@ -145,7 +150,8 @@ describe Gitlab::Metrics::Dashboard::Processor do
       unit: metric.unit,
       label: metric.legend,
       metric_id: metric.id,
-      prometheus_endpoint_path: prometheus_path(metric.query)
+      prometheus_endpoint_path: prometheus_path(metric.query),
+      edit_path: edit_metric_path(metric)
     }
   end
 
@@ -165,4 +171,11 @@ describe Gitlab::Metrics::Dashboard::Processor do
       identifier: metric
     )
   end
+
+  def edit_metric_path(metric)
+    Gitlab::Routing.url_helpers.edit_project_prometheus_metric_path(
+      project,
+      metric.id
+    )
+  end
 end
diff --git a/spec/models/pages_domain_spec.rb b/spec/models/pages_domain_spec.rb
index 99b7c4f148a..d2a54c3eea7 100644
--- a/spec/models/pages_domain_spec.rb
+++ b/spec/models/pages_domain_spec.rb
@@ -104,6 +104,14 @@ describe PagesDomain do
   describe 'validate certificate' do
     subject { domain }
 
+    context 'serverless domain' do
+      it 'requires certificate and key to be present' do
+        expect(build(:pages_domain, :without_certificate, :without_key, usage: :serverless)).not_to be_valid
+        expect(build(:pages_domain, :without_certificate, usage: :serverless)).not_to be_valid
+        expect(build(:pages_domain, :without_key, usage: :serverless)).not_to be_valid
+      end
+    end
+
     context 'with matching key' do
       let(:domain) { build(:pages_domain) }
 
@@ -555,6 +563,28 @@ describe PagesDomain do
     end
   end
 
+  describe '.instance_serverless' do
+    subject { described_class.instance_serverless }
+
+    before do
+      create(:pages_domain, wildcard: true)
+      create(:pages_domain, :instance_serverless)
+      create(:pages_domain, scope: :instance)
+      create(:pages_domain, :instance_serverless)
+      create(:pages_domain, usage: :serverless)
+    end
+
+    it 'returns domains that are wildcard, instance-level, and serverless' do
+      expect(subject.length).to eq(2)
+
+      subject.each do |domain|
+        expect(domain.wildcard).to eq(true)
+        expect(domain.usage).to eq('serverless')
+        expect(domain.scope).to eq('instance')
+      end
+    end
+  end
+
   describe '.need_auto_ssl_renewal' do
     subject { described_class.need_auto_ssl_renewal }
 
diff --git a/spec/requests/api/commits_spec.rb b/spec/requests/api/commits_spec.rb
index 170b9ccccf8..c179de249d5 100644
--- a/spec/requests/api/commits_spec.rb
+++ b/spec/requests/api/commits_spec.rb
@@ -266,8 +266,30 @@ describe API::Commits do
           end
         end
 
-        context 'set to blank' do
-          let(:order) { '' }
+        context 'set to default' do
+          let(:order) { 'default' }
+
+          # git log --graph -n 6 --pretty=format:"%h" --date-order 0031876
+          # *   0031876
+          # |\
+          # * | bf6e164
+          # | * 48ca272
+          # * | 9d526f8
+          # | * 335bc94
+          # |/
+          # * 1039376
+          it 'returns project commits ordered by default order' do
+            commits = project.repository.commits("0031876", limit: 6, order: 'default')
+
+            get api(route, current_user)
+
+            expect(json_response.size).to eq(6)
+            expect(json_response.map { |entry| entry["id"] }).to eq(commits.map(&:id))
+          end
+        end
+
+        context 'set to an invalid parameter' do
+          let(:order) { 'invalid' }
 
           it_behaves_like '400 response' do
             let(:request) { get api(route, current_user) }
diff --git a/spec/routing/admin/serverless/domains_controller_routing_spec.rb b/spec/routing/admin/serverless/domains_controller_routing_spec.rb
new file mode 100644
index 00000000000..18c0db6add1
--- /dev/null
+++ b/spec/routing/admin/serverless/domains_controller_routing_spec.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Admin::Serverless::DomainsController do
+  it 'routes to #index' do
+    expect(get: '/admin/serverless/domains').to route_to('admin/serverless/domains#index')
+  end
+
+  it 'routes to #create' do
+    expect(post: '/admin/serverless/domains/').to route_to('admin/serverless/domains#create')
+  end
+
+  it 'routes to #update' do
+    expect(put: '/admin/serverless/domains/1').to route_to(controller: 'admin/serverless/domains', action: 'update', id: '1')
+    expect(patch: '/admin/serverless/domains/1').to route_to(controller: 'admin/serverless/domains', action: 'update', id: '1')
+  end
+
+  it 'routes #verify' do
+    expect(post: '/admin/serverless/domains/1/verify').to route_to(controller: 'admin/serverless/domains', action: 'verify', id: '1')
+  end
+end
diff --git a/spec/services/snippets/create_service_spec.rb b/spec/services/snippets/create_service_spec.rb
index 1cf1cff51ed..a1cbec6748a 100644
--- a/spec/services/snippets/create_service_spec.rb
+++ b/spec/services/snippets/create_service_spec.rb
@@ -164,7 +164,9 @@ describe Snippets::CreateService do
         it 'does not create snippet repository' do
           stub_feature_flags(version_snippets: false)
 
-          subject
+          expect do
+            subject
+          end.to change(Snippet, :count).by(1)
 
           expect(snippet.repository_exists?).to be_falsey
         end