1 files changed, 147 insertions, 133 deletions

diff --git a/spec/requests/api/lint_spec.rb b/spec/requests/api/lint_spec.rb
index 3f131862a41..bc535e7e38a 100644
--- a/spec/requests/api/lint_spec.rb
+++ b/spec/requests/api/lint_spec.rb
@@ -4,168 +4,139 @@ require 'spec_helper'
 
 RSpec.describe API::Lint, feature_category: :pipeline_composition do
   describe 'POST /ci/lint' do
-    context 'when signup settings are disabled' do
-      before do
-        Gitlab::CurrentSettings.signup_enabled = false
-      end
+    it 'responds with a 410' do
+      user = create(:user)
 
-      context 'when unauthenticated' do
-        it 'returns authentication error' do
-          post api('/ci/lint'), params: { content: 'content' }
+      post api('/ci/lint', user), params: { content: "test_job:\n  script: ls" }
 
-          expect(response).to have_gitlab_http_status(:unauthorized)
-        end
-      end
-
-      context 'when authenticated' do
-        let_it_be(:api_user) { create(:user) }
-
-        it 'returns authorized' do
-          post api('/ci/lint', api_user), params: { content: 'content' }
+      expect(response).to have_gitlab_http_status(:gone)
+    end
 
-          expect(response).to have_gitlab_http_status(:ok)
-        end
+    context 'when ci_remove_post_lint is disabled' do
+      before do
+        stub_feature_flags(ci_remove_post_lint: false)
       end
 
-      context 'when authenticated as external user' do
-        let(:project) { create(:project) }
-        let(:api_user) { create(:user, :external) }
-
-        context 'when reporter in a project' do
-          before do
-            project.add_reporter(api_user)
-          end
+      context 'when signup settings are disabled' do
+        before do
+          Gitlab::CurrentSettings.signup_enabled = false
+        end
 
-          it 'returns authorization failure' do
-            post api('/ci/lint', api_user), params: { content: 'content' }
+        context 'when unauthenticated' do
+          it 'returns authentication error' do
+            post api('/ci/lint'), params: { content: 'content' }
 
             expect(response).to have_gitlab_http_status(:unauthorized)
           end
         end
 
-        context 'when developer in a project' do
-          before do
-            project.add_developer(api_user)
-          end
+        context 'when authenticated' do
+          let_it_be(:api_user) { create(:user) }
 
-          it 'returns authorization success' do
+          it 'returns authorized' do
             post api('/ci/lint', api_user), params: { content: 'content' }
 
             expect(response).to have_gitlab_http_status(:ok)
           end
         end
-      end
-    end
 
-    context 'when signup is enabled and not limited' do
-      before do
-        Gitlab::CurrentSettings.signup_enabled = true
-        stub_application_setting(domain_allowlist: [], email_restrictions_enabled: false, require_admin_approval_after_user_signup: false)
-      end
+        context 'when authenticated as external user' do
+          let(:project) { create(:project) }
+          let(:api_user) { create(:user, :external) }
 
-      context 'when unauthenticated' do
-        it 'returns authorized success' do
-          post api('/ci/lint'), params: { content: 'content' }
+          context 'when reporter in a project' do
+            before do
+              project.add_reporter(api_user)
+            end
 
-          expect(response).to have_gitlab_http_status(:ok)
-        end
-      end
+            it 'returns authorization failure' do
+              post api('/ci/lint', api_user), params: { content: 'content' }
 
-      context 'when authenticated' do
-        let_it_be(:api_user) { create(:user) }
+              expect(response).to have_gitlab_http_status(:unauthorized)
+            end
+          end
 
-        it 'returns authentication success' do
-          post api('/ci/lint', api_user), params: { content: 'content' }
+          context 'when developer in a project' do
+            before do
+              project.add_developer(api_user)
+            end
 
-          expect(response).to have_gitlab_http_status(:ok)
+            it 'returns authorization success' do
+              post api('/ci/lint', api_user), params: { content: 'content' }
+
+              expect(response).to have_gitlab_http_status(:ok)
+            end
+          end
         end
       end
-    end
 
-    context 'when limited signup is enabled' do
-      before do
-        stub_application_setting(domain_allowlist: ['www.gitlab.com'])
-        Gitlab::CurrentSettings.signup_enabled = true
-      end
+      context 'when signup is enabled and not limited' do
+        before do
+          Gitlab::CurrentSettings.signup_enabled = true
+          stub_application_setting(domain_allowlist: [], email_restrictions_enabled: false, require_admin_approval_after_user_signup: false)
+        end
 
-      context 'when unauthenticated' do
-        it 'returns unauthorized' do
-          post api('/ci/lint'), params: { content: 'content' }
+        context 'when unauthenticated' do
+          it 'returns authorized success' do
+            post api('/ci/lint'), params: { content: 'content' }
 
-          expect(response).to have_gitlab_http_status(:unauthorized)
+            expect(response).to have_gitlab_http_status(:ok)
+          end
         end
-      end
 
-      context 'when authenticated' do
-        let_it_be(:api_user) { create(:user) }
+        context 'when authenticated' do
+          let_it_be(:api_user) { create(:user) }
 
-        it 'returns authentication success' do
-          post api('/ci/lint', api_user), params: { content: 'content' }
+          it 'returns authentication success' do
+            post api('/ci/lint', api_user), params: { content: 'content' }
 
-          expect(response).to have_gitlab_http_status(:ok)
+            expect(response).to have_gitlab_http_status(:ok)
+          end
         end
       end
-    end
 
-    context 'when authenticated' do
-      let_it_be(:api_user) { create(:user) }
-
-      context 'with valid .gitlab-ci.yml content' do
-        let(:yaml_content) do
-          File.read(Rails.root.join('spec/support/gitlab_stubs/gitlab_ci.yml'))
+      context 'when limited signup is enabled' do
+        before do
+          stub_application_setting(domain_allowlist: ['www.gitlab.com'])
+          Gitlab::CurrentSettings.signup_enabled = true
         end
 
-        it 'passes validation without warnings or errors' do
-          post api('/ci/lint', api_user), params: { content: yaml_content }
+        context 'when unauthenticated' do
+          it 'returns unauthorized' do
+            post api('/ci/lint'), params: { content: 'content' }
 
-          expect(response).to have_gitlab_http_status(:ok)
-          expect(json_response).to be_an Hash
-          expect(json_response['status']).to eq('valid')
-          expect(json_response['warnings']).to match_array([])
-          expect(json_response['errors']).to match_array([])
-          expect(json_response['includes']).to eq([])
+            expect(response).to have_gitlab_http_status(:unauthorized)
+          end
         end
 
-        it 'outputs expanded yaml content' do
-          post api('/ci/lint', api_user), params: { content: yaml_content, include_merged_yaml: true }
-
-          expect(response).to have_gitlab_http_status(:ok)
-          expect(json_response).to have_key('merged_yaml')
-        end
+        context 'when authenticated' do
+          let_it_be(:api_user) { create(:user) }
 
-        it 'outputs jobs' do
-          post api('/ci/lint', api_user), params: { content: yaml_content, include_jobs: true }
+          it 'returns authentication success' do
+            post api('/ci/lint', api_user), params: { content: 'content' }
 
-          expect(response).to have_gitlab_http_status(:ok)
-          expect(json_response).to have_key('jobs')
+            expect(response).to have_gitlab_http_status(:ok)
+          end
         end
       end
 
-      context 'with valid .gitlab-ci.yml with warnings' do
-        let(:yaml_content) { { job: { script: 'ls', rules: [{ when: 'always' }] } }.to_yaml }
-
-        it 'passes validation but returns warnings' do
-          post api('/ci/lint', api_user), params: { content: yaml_content }
-
-          expect(response).to have_gitlab_http_status(:ok)
-          expect(json_response['status']).to eq('valid')
-          expect(json_response['warnings']).not_to be_empty
-          expect(json_response['errors']).to match_array([])
-        end
-      end
+      context 'when authenticated' do
+        let_it_be(:api_user) { create(:user) }
 
-      context 'with an invalid .gitlab-ci.yml' do
-        context 'with invalid syntax' do
-          let(:yaml_content) { 'invalid content' }
+        context 'with valid .gitlab-ci.yml content' do
+          let(:yaml_content) do
+            File.read(Rails.root.join('spec/support/gitlab_stubs/gitlab_ci.yml'))
+          end
 
-          it 'responds with errors about invalid syntax' do
+          it 'passes validation without warnings or errors' do
             post api('/ci/lint', api_user), params: { content: yaml_content }
 
             expect(response).to have_gitlab_http_status(:ok)
-            expect(json_response['status']).to eq('invalid')
-            expect(json_response['warnings']).to eq([])
-            expect(json_response['errors']).to eq(['Invalid configuration format'])
-            expect(json_response['includes']).to eq(nil)
+            expect(json_response).to be_an Hash
+            expect(json_response['status']).to eq('valid')
+            expect(json_response['warnings']).to match_array([])
+            expect(json_response['errors']).to match_array([])
+            expect(json_response['includes']).to eq([])
           end
 
           it 'outputs expanded yaml content' do
@@ -183,41 +154,84 @@ RSpec.describe API::Lint, feature_category: :pipeline_composition do
           end
         end
 
-        context 'with invalid configuration' do
-          let(:yaml_content) { '{ image: "image:1.0",  services: ["postgres"] }' }
+        context 'with valid .gitlab-ci.yml with warnings' do
+          let(:yaml_content) { { job: { script: 'ls', rules: [{ when: 'always' }] } }.to_yaml }
 
-          it 'responds with errors about invalid configuration' do
+          it 'passes validation but returns warnings' do
             post api('/ci/lint', api_user), params: { content: yaml_content }
 
             expect(response).to have_gitlab_http_status(:ok)
-            expect(json_response['status']).to eq('invalid')
-            expect(json_response['warnings']).to eq([])
-            expect(json_response['errors']).to eq(['jobs config should contain at least one visible job'])
-            expect(json_response['includes']).to eq([])
+            expect(json_response['status']).to eq('valid')
+            expect(json_response['warnings']).not_to be_empty
+            expect(json_response['errors']).to match_array([])
           end
+        end
 
-          it 'outputs expanded yaml content' do
-            post api('/ci/lint', api_user), params: { content: yaml_content, include_merged_yaml: true }
+        context 'with an invalid .gitlab-ci.yml' do
+          context 'with invalid syntax' do
+            let(:yaml_content) { 'invalid content' }
 
-            expect(response).to have_gitlab_http_status(:ok)
-            expect(json_response).to have_key('merged_yaml')
+            it 'responds with errors about invalid syntax' do
+              post api('/ci/lint', api_user), params: { content: yaml_content }
+
+              expect(response).to have_gitlab_http_status(:ok)
+              expect(json_response['status']).to eq('invalid')
+              expect(json_response['warnings']).to eq([])
+              expect(json_response['errors']).to eq(['Invalid configuration format'])
+              expect(json_response['includes']).to eq(nil)
+            end
+
+            it 'outputs expanded yaml content' do
+              post api('/ci/lint', api_user), params: { content: yaml_content, include_merged_yaml: true }
+
+              expect(response).to have_gitlab_http_status(:ok)
+              expect(json_response).to have_key('merged_yaml')
+            end
+
+            it 'outputs jobs' do
+              post api('/ci/lint', api_user), params: { content: yaml_content, include_jobs: true }
+
+              expect(response).to have_gitlab_http_status(:ok)
+              expect(json_response).to have_key('jobs')
+            end
           end
 
-          it 'outputs jobs' do
-            post api('/ci/lint', api_user), params: { content: yaml_content, include_jobs: true }
+          context 'with invalid configuration' do
+            let(:yaml_content) { '{ image: "image:1.0",  services: ["postgres"] }' }
 
-            expect(response).to have_gitlab_http_status(:ok)
-            expect(json_response).to have_key('jobs')
+            it 'responds with errors about invalid configuration' do
+              post api('/ci/lint', api_user), params: { content: yaml_content }
+
+              expect(response).to have_gitlab_http_status(:ok)
+              expect(json_response['status']).to eq('invalid')
+              expect(json_response['warnings']).to eq([])
+              expect(json_response['errors']).to eq(['jobs config should contain at least one visible job'])
+              expect(json_response['includes']).to eq([])
+            end
+
+            it 'outputs expanded yaml content' do
+              post api('/ci/lint', api_user), params: { content: yaml_content, include_merged_yaml: true }
+
+              expect(response).to have_gitlab_http_status(:ok)
+              expect(json_response).to have_key('merged_yaml')
+            end
+
+            it 'outputs jobs' do
+              post api('/ci/lint', api_user), params: { content: yaml_content, include_jobs: true }
+
+              expect(response).to have_gitlab_http_status(:ok)
+              expect(json_response).to have_key('jobs')
+            end
           end
         end
-      end
 
-      context 'without the content parameter' do
-        it 'responds with validation error about missing content' do
-          post api('/ci/lint', api_user)
+        context 'without the content parameter' do
+          it 'responds with validation error about missing content' do
+            post api('/ci/lint', api_user)
 
-          expect(response).to have_gitlab_http_status(:bad_request)
-          expect(json_response['error']).to eq('content is missing')
+            expect(response).to have_gitlab_http_status(:bad_request)
+            expect(json_response['error']).to eq('content is missing')
+          end
         end
       end
     end