gitlab-qa 15.2.0 → 15.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 793b59a3d3817c1e3fa0794cfceaf8f80bc7a193e46e9ce3704ce8b8301e9143
-  data.tar.gz: 299f7ce902fd8b9603cda51c2f5f018ff5c7a230b01944ca99c0eea9168ccc0a
+  metadata.gz: 8f1e475ea2c0271c08caf2de2d91881fb387148ee9a0686922e5c13905dfbae9
+  data.tar.gz: aecf00278bb4ae18d9a4b0b3e1d42d80f3a9b5482a38d755c83a2fa0fc3046ef
 SHA512:
-  metadata.gz: 253cc2d2d41a94030bcb6c0b5a0225ff46ff9019677b8b1486104ee556fb219ecda07bbe724c51ed822699c0e2c2ccc0273795b122e810971bc956aa16af14ee
-  data.tar.gz: eb4f3be8907209202af1aa51f9c1b8c70523645f31afdda60a294bbe7972ec769c1199fb8ca7075b46c862ad3161b1e3d5bd2369a2fe587a929bc2052f7ee208
+  metadata.gz: 164f25be24c4f6800d9dbb150776876a38e85c5bebcac4a72f449a0ed8e6ac2b65b89502cff82c588f101b6a9b299f3fbc2735f99d4a829990e85cdf5fc5674d
+  data.tar.gz: f1bbdd00cb493f5f6cb0a4f48af319503e3526515f12edceb631868194183e0910b08cedbdbf9e92f59177a7632a63b459bef681555b806eecf72bd6def571a7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gitlab-qa (15.2.0)
+    gitlab-qa (15.4.0)
       activesupport (>= 6.1, < 7.2)
       ffi (~> 1.17)
       gitlab (~> 4.19)

data/README.md

@@ -90,9 +90,8 @@ of tests.
 - [Release process](docs/release_process.md)
 - [Run QA tests against your GDK setup](docs/run_qa_against_gdk.md)
 - [Trainings](docs/trainings.md)
-- [Waits](docs/waits.md)
 - [What tests can be run?](docs/what_tests_can_be_run.md)
-- [Specifics for Mac OS with M1, M2 processors & Docker Desktop](docs/specifics_for_macos_m1_m2.md)
+- [Troubleshooting](docs/troubleshooting.md)
 
 ## How do we use it
 

data/docs/developer/http_mocking.md

@@ -24,5 +24,5 @@ end
 ```
 
 Mock server will be accessible from within gitlab or qa test container via `http://smocker.test` url and admin interface will be
-accessible via `http://smocker.test:8081`. Refer to [Getting Started](https://smocker.dev/guide/getting-started.html) guide on
+accessible via `http://smocker.test:8081`. Refer to [Getting Started](https://smocker.dev/docs/guide/getting-started) guide on
 how to use the server and define mocked requests and responses.

data/docs/what_tests_can_be_run.md

@@ -299,11 +299,11 @@ $ gitlab-qa Test::Omnibus::Upgrade CE
 $ gitlab-qa Test::Omnibus::Upgrade gitlab/gitlab-ce:my-custom-tag
 ```
 
-### `Test::Omnibus::UpdateFromPrevious <full image address> <current_version> <major|minor> <from_edition>`
+### `Test::Omnibus::UpdateFromPrevious <full image address> <current_version> <major|minor|patch> <from_edition>`
 
-Scenario verifies upgrade from previous (major|minor) version to current release.
+Scenario verifies upgrade from previous (major|minor|patch) version to current release.
 
-- Deploys previous (major|minor) version and runs Smoke test suite
+- Deploys previous (major|minor|patch) version and runs Health Check test suite (Smoke test suite if below 17.1.0)
   to populate data in database before upgrade
 - Generates upgrade path following current GitLab recommendations
   from ['gitlab.com/gitlab-org/gitlab'](https://gitlab.com/gitlab-org/gitlab/-/raw/master/config/upgrade_path.yml) project
@@ -318,6 +318,30 @@ $ gitlab-qa Test::Omnibus::UpdateFromPrevious gitlab-ee:dev-tag 15.6.0-pre minor
 
 # Major upgrade - will perform upgrades 14.10.x -> 15.0.x -> 15.4.x -> gitlab-ee:dev-tag (15.6.0-pre)
 $ gitlab-qa Test::Omnibus::UpdateFromPrevious gitlab-ee:dev-tag 15.6.0-pre major
+
+# Patch upgrade - will perform upgrade from 17.8.1 -> gitlab-ee:dev-tag (17.8.2-pre)
+$ gitlab-qa Test::Omnibus::UpdateFromPrevious gitlab-ee:dev-tag 17.8.2-pre patch
+
+# Internal patch upgrade - will perform upgrade from dev.gitlab.org:5005/gitlab/omnibus-gitlab/gitlab-ee:17.8.1-internal0-0 -> gitlab-ee:dev-tag (17.8.2-pre)
+$ gitlab-qa Test::Omnibus::UpdateFromPrevious gitlab-ee:dev-tag 17.8.2-pre internal_patch
+```
+
+### `Test::Omnibus::UpdateToNext <full image address> <current_version> <from_edition>`
+
+Scenario verifies upgrade from current development version to next available stable release.
+
+- Deploys development version and runs Health Check test suite to populate data in database (Smoke test suite if below 17.1.0)
+- Finds next available stable version
+- Upgrades GitLab instance from development version to next stable and runs tests against it
+- Skips if either current version or next version is not yet released
+
+Note: `from_edition` setting is optional, can be set to `ee` or `ce`.
+
+Example:
+
+```shell
+# Will perform upgrade from gitlab-ee:dev-tag (17.8.2-pre) -> 17.9.2
+$ gitlab-qa Test::Omnibus::UpdateToNext gitlab-ee:dev-tag 17.8.2-pre
 ```
 
 ### `Test::Integration::Geo EE|<full image address>`
@@ -1049,6 +1073,29 @@ This orchestrated scenario runs tests from the test suite against a GitLab insta
 
 These variables are available at 1Password QA Vault.
 
+----
+
+#### `Test::Instance::SecureVersion EE|<full image address>`
+
+Used for testing that a project with Secure scanner functionality functions correctly against the specified version.
+As this is Secure functionality, an EE license is required.
+Can be used for running older instances of GitLab, this skips the Security version modal on login.
+
+The script applies the license, imports the project, kicks off a pipeline, and checks that the pipeline was successful.
+
+**Required environment variables:**
+
+- `EE_LICENSE`: A valid EE license for testing.
+- `PROJECT_URL`: The URL of the project to test.
+- `PROJECT_NAME`: The name of the project to test, when imported to the instance.
+
+Example:
+
+```shell
+$ export EE_LICENSE=$(cat /path/to/gitlab_license)
+$ PROJECT_URL='https://gitlab.com/gitlab-org/quality/ci/secure-testing/secure-matrix-test.git' PROJECT_NAME='secure-matrix-test' gitlab-qa Test::Instance::SecureVersion gitlab/gitlab-ee:16.5.0-ee.0
+```
+
 ### `Test::Integration::RegistryTLS EE`
 
 It uses GitLab's TLS certificate found in the [`tls_certificates`](https://gitlab.com/gitlab-org/gitlab-qa/-/blob/master/tls_certificates/gitlab/gitlab.test.crt) folder.
@@ -1236,4 +1283,16 @@ $ gitlab-qa Test::Integration::AiGatewayNoLicense EE
 
 ----
 
+#### Troubleshooting `AiGateway` Tests
+
+The following logs are available for troubleshooting `AiGateway` tests in the `e2e-test-on-omnibus` pipelines.
+
+| Component            | Log Location                                                                                                                                                           | Additional Info                                                                                                                                       |
+|----------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+| CustomersDot Staging | [Kibana](https://nonprod-log.gitlab.net/) (`pubsub-rails-inf-stgsub*`), [Sentry](https://new-sentry.gitlab.net/organizations/gitlab/issues/?environment=stg&project=8) | See [CustomersDot Logging](https://gitlab.com/gitlab-org/customers-gitlab-com/blob/main/doc/architecture/logging.md#customersdot-logging) for details |
+| GitLab Omnibus       | Job artifacts: `gitlab/logs`                                                                                                                                           | See the GitLab [Log system](https://docs.gitlab.com/ee/administration/logs/) docs for more details                                                    |
+| AI Gateway           | Job artifacts: `ai-gateway/logs/modelgateway_debug.log`                                                                                                                | See the AI Gateway's [README](https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist#gitlab-ai-gateway) for more details        |
+
+----
+
 [Back to README.md](../README.md)

data/lib/gitlab/qa/component/license_ops.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Component
+      class LicenseOps < Base
+        LicenseError = Class.new(StandardError)
+        require 'shellwords'
+
+        def add_license(gitlab)
+          license_key = fetch_license_key
+          command = build_license_command(license_key)
+          apply_license(gitlab, command, license_key)
+        end
+
+        private
+
+        def fetch_license_key
+          license_key = ENV.fetch('EE_LICENSE', '')
+          raise LicenseError, "EE_LICENSE environment variable is not set or is empty" if license_key.empty?
+
+          Shellwords.shellwords(license_key).join
+        end
+
+        def build_license_command(license_key)
+          script = <<~RUBY
+            key = ENV['EE_LICENSE']
+            license = License.new(data: key)
+            if license.save
+              puts "License applied successfully"
+            else
+              STDERR.puts "Failed to apply license"
+            end
+          RUBY
+          "EE_LICENSE='#{license_key}' gitlab-rails runner $'#{script.gsub("'", "\\\\'").gsub("\n", '\\n')}'"
+        end
+
+        def apply_license(gitlab, command, license_key)
+          result = gitlab.docker.exec(gitlab.name, command, mask_secrets: license_key)
+          verify_license_application(result)
+        end
+
+        def verify_license_application(result)
+          return if result.include?("License applied successfully")
+
+          raise LicenseError, "Failed to apply license."
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/qa/component/pipeline_ops.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Component
+      class PipelineOps < Base
+        def start(gitlab, project_name)
+          create_and_execute_pipeline_script(gitlab, project_name)
+        end
+
+        def check_status(gitlab)
+          pipeline_status = gitlab.docker.exec(
+            gitlab.name, wait_for_pipeline)
+
+          case pipeline_status
+          when 'success'
+            puts "Pipeline succeeded!"
+            nil
+          when 'failed'
+            raise StandardError, "Pipeline failed."
+          else
+            puts "Pipeline is currently #{pipeline_status}"
+          end
+        end
+
+        private
+
+        def create_and_execute_pipeline_script(gitlab, project_name)
+          setup_src_path = File.expand_path('../../../../support/pipeline', __dir__)
+          setup_dest_path = '/tmp/setup-scripts'
+
+          gitlab.docker.copy(gitlab.name, setup_src_path, setup_dest_path)
+
+          gitlab.docker.exec(
+            gitlab.name,
+            "PROJECT_NAME='#{project_name}' gitlab-rails runner #{setup_dest_path}/create_for_projectname.rb"
+          )
+        end
+
+        def wait_for_pipeline
+          <<~SHELL
+            gitlab-rails runner "
+              latest_pipeline = Ci::Pipeline.last
+              # wait for the pipeline to complete
+              loop do
+                latest_pipeline.reload
+                break if latest_pipeline.complete?
+                sleep 1
+              end
+              puts latest_pipeline.status
+            "
+          SHELL
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/qa/component/project_importer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Component
+      class ProjectImporter < Base
+        IMPORT_TIMEOUT = 300 # 5 minutes
+
+        def initialize(project_url, project_name, project_path: project_name)
+          @project_name = project_name
+          @project_url = project_url
+          @project_path = project_path
+        end
+
+        def import_project(gitlab)
+          import_command = build_import_command(create_import_script, @project_url, @project_name, @project_path)
+          puts gitlab.docker.exec(gitlab.name, import_command)
+        end
+
+        private
+
+        def create_import_script
+          <<~'RUBY'
+            require 'timeout'
+
+            project_url = ENV.fetch('PROJECT_URL')
+            project_name = ENV.fetch('PROJECT_NAME')
+            project_path = ENV.fetch('PROJECT_PATH')
+
+            root_user = User.find_by_username('root')
+
+            project = Projects::CreateService.new(root_user,
+              { name: project_name, path: project_path, import_url: project_url }).execute
+
+            if project.persisted?
+              # Wait for import to complete
+              begin
+                Timeout.timeout(300) do # 5 minutes timeout
+                  until ['finished', 'failed'].include?(project.import_status)
+                    sleep 5
+                    project.reload
+                  end
+                end
+              rescue Timeout::Error
+                puts "Import process timed out after 5 minutes"
+              end
+            else
+              puts "Failed to create project: #{project.errors.full_messages.join(', ')}"
+            end
+
+            # Always print import state for debugging
+            puts "Import state: #{project.import_state.attributes}" if project.respond_to?(:import_state)
+          RUBY
+        end
+
+        def build_import_command(script, project_url, project_name, project_path)
+          escaped_script = script.gsub("'", "\\\\'").gsub("\n", "\\n")
+          "PROJECT_URL='#{project_url}' PROJECT_NAME='#{project_name}' PROJECT_PATH='#{project_path}' gitlab-rails runner $'#{escaped_script}'"
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/qa/component/runner_ops.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Component
+      class RunnerOps < Base
+        include Support::Shellout
+
+        RUNNER_DESCRIPTION = "QA Runner"
+        DOCKER_IMAGE = "registry.gitlab.com/gitlab-org/gitlab-runner:alpine"
+        BUILD_IMAGE = "registry.gitlab.com/gitlab-org/gitlab-build-images:gitlab-qa-alpine-ruby-2.7"
+
+        def setup_runner(gitlab)
+          token = SecureRandom.hex(15)
+          add_runner_to_gitlab(gitlab, token)
+          register_docker_runner(gitlab, token)
+        end
+
+        private
+
+        def add_runner_to_gitlab(gitlab, token)
+          gitlab.docker.exec(
+            gitlab.name,
+            create_runner_command(token),
+            mask_secrets: token
+          )
+        end
+
+        def create_runner_command(token)
+          <<~RUBY.strip.gsub(/\s+/, ' ')
+            gitlab-rails runner '
+              Ci::Runner.create!(
+                description: "#{RUNNER_DESCRIPTION}",
+                run_untagged: true,
+                active: true,
+                token: "#{token}",
+                runner_type: :instance_type
+              );
+              puts "Runner created"
+            '
+          RUBY
+        end
+
+        def register_docker_runner(gitlab, token)
+          runner_name = generate_runner_name
+          docker_command = build_docker_command(
+            runner_name: runner_name,
+            network: gitlab.network,
+            address: gitlab.address,
+            token: token
+          )
+
+          shell(docker_command, mask_secrets: [token])
+        end
+
+        def generate_runner_name
+          "test-runner-#{SecureRandom.hex(4)}"
+        end
+
+        def build_docker_command(runner_name:, network:, address:, token:)
+          <<~CMD.tr("\n", ' ')
+            docker run -d --rm --network #{network} --name #{runner_name}
+            -v /var/run/docker.sock:/var/run/docker.sock
+            --privileged
+            #{DOCKER_IMAGE}
+            && docker exec --detach #{runner_name} sh -c "#{register_command(runner_name, address, token, network)}"
+          CMD
+        end
+
+        def runner_config
+          <<~CONFIG
+            concurrent = 1
+            check_interval = 0
+
+            [session_server]
+              session_timeout = 1800
+          CONFIG
+        end
+
+        def register_command(name, address, token, network)
+          registration_args = build_registration_args(
+            name: name,
+            address: address,
+            token: token,
+            network: network
+          )
+
+          <<~CMD.strip
+            printf '#{runner_config.chomp.gsub(/\n/, '\\n').gsub('"', '\"')}' > /etc/gitlab-runner/config.toml  &&
+            gitlab-runner register #{registration_args} &&
+            gitlab-runner run
+          CMD
+        end
+
+        def build_registration_args(name:, address:, token:, network:)
+          [
+            '--non-interactive',
+            "--name #{name}",
+            "--url #{address}",
+            "--token #{token}",
+            '--run-untagged=true',
+            '--executor docker',
+            "--docker-image #{BUILD_IMAGE}",
+            '--docker-tlsverify=false',
+            '--docker-privileged=true',
+            "--docker-network-mode=#{network}",
+            '--docker-volumes=/certs/client'
+          ].join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/qa/docker/engine.rb

@@ -81,6 +81,18 @@ module Gitlab
           ), mask_secrets: mask_secrets)
         end
 
+        # Executes a command inside a running Docker container.
+        #
+        # @param name [String] The name or ID of the container to execute the command in.
+        # @param command [String] The command to be executed inside the container.
+        # @param mask_secrets [Boolean, nil] Whether to mask sensitive information in logs. Defaults to nil.
+        # @param shell [String] The shell to use for executing the command. Defaults to "bash".
+        #
+        # @return [String] The output of the executed command.
+        #
+        # @example
+        #   exec("my-container", "echo 'hello world'")
+        #   # => "hello world\n"
         def exec(name, command, mask_secrets: nil, shell: "bash")
           cmd = ['exec']
           cmd << '--privileged' if privileged_command?(command)

data/lib/gitlab/qa/release.rb

@@ -37,7 +37,7 @@ module Gitlab
       # version
       DEV_OFFICIAL_TAG_REGEX = /
         \A
-          (?<version>\d+\.\d+.\d+(?:-rc\d+)?)-(?<edition>ce|ee|jh)
+          (?<version>\d+\.\d+.\d+(?:-rc\d+)?)-(?<edition>ce|ee|jh)(?:\.(?<build>\d+))?
         \z
       /xi
 
@@ -115,6 +115,11 @@ module Gitlab
                         omnibus_project = image.match(CUSTOM_GITLAB_IMAGE_REGEX)[:project]
                         gitlab_project = ci_project_path ? "/#{ci_project_path}/" : "/gitlab-org/gitlab/"
 
+                        "#{image.gsub(omnibus_project, gitlab_project)}-qa"
+                      elsif dev_gitlab_org?
+                        omnibus_project = image.match(CUSTOM_GITLAB_IMAGE_REGEX)[:project]
+                        gitlab_project = "/gitlab/gitlab-ee/"
+
                         "#{image.gsub(omnibus_project, gitlab_project)}-qa"
                       else
                         "#{image}-qa"
@@ -140,9 +145,14 @@ module Gitlab
           end
       end
 
-      # Tag scheme for gitlab-{ce,ee}-qa images is like 11.1.0-rc12-ee
       def qa_tag
-        if dev_gitlab_org? && (match_data = tag.match(DEV_TAG_REGEX))
+        # Case 1: Official packages (e.g., 11.1.0-rc12.ee.0 or 12.5.4-ce.1)
+        if match_data = tag.match(DEV_OFFICIAL_TAG_REGEX)
+          version = match_data[:version]
+          edition = match_data[:edition]
+          "#{version}-#{edition}"
+        # Case 2: Auto-deploy packages from dev.gitlab.org (e.g., 12.1.201906121026-325a6632895.b340d0bd35d)
+        elsif match_data = tag.match(DEV_TAG_REGEX)
           match_data[:gitlab_ref]
         else
           tag.sub(/[-.]([ce]e)(\.(\d+))?\z/, '-\1')

data/lib/gitlab/qa/scenario/test/instance/secure_version.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Scenario
+      module Test
+        module Instance
+          class SecureVersion < Scenario::Template
+            include Support::Shellout
+
+            attr_writer :volumes, :seed_admin_token
+
+            def initialize
+              @volumes = {}
+              @seed_admin_token = true
+              @pipeline_ops = Component::PipelineOps.new
+              @runner_ops = Component::RunnerOps.new
+              @importer = Component::ProjectImporter.new(
+                ENV.fetch('PROJECT_URL', nil),
+                ENV.fetch('PROJECT_NAME', nil))
+              @license_ops = Component::LicenseOps.new
+            end
+
+            def perform(release, *_rspec_args)
+              Component::Gitlab.perform do |gitlab|
+                setup_gitlab(gitlab, release)
+                execute_gitlab_operations(gitlab)
+              end
+            end
+
+            private
+
+            def setup_gitlab(gitlab, release)
+              gitlab.release = release
+              gitlab.volumes = @volumes
+              gitlab.network = Runtime::Env.docker_network
+              gitlab.name = Runtime::Env.qa_gitlab_hostname
+              gitlab.seed_admin_token = @seed_admin_token
+              gitlab.tls = Runtime::Env.qa_gitlab_use_tls?
+              # gitlab.exec_commands = foo
+            end
+
+            def execute_gitlab_operations(gitlab)
+              gitlab.instance do
+                @license_ops.add_license(gitlab)
+                @runner_ops.setup_runner(gitlab)
+                @importer.import_project(gitlab)
+                @pipeline_ops.start(gitlab, 'secure-matrix-test')
+                @pipeline_ops.check_status(gitlab)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/qa/scenario/test/omnibus/update_to_next.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Scenario
+      module Test
+        module Omnibus
+          class UpdateToNext < UpdateFromPrevious
+            using Rainbow
+            # Test upgrade from development version to next stable release
+            #
+            # @example
+            # perform(gitlab-ee:dev-tag, 17.8.2-pre)
+            # => will perform upgrade gitlab-ee:dev-tag -> 17.9.2
+            #
+            # @param [String] release current release docker image with development changes
+            # @param [String] current_version current gitlab version associated with docker image
+            # @param [String] from_edition gitlab edition to update from
+            # @param [Array] *rspec_args rspec arguments
+            # @return [void]
+            def perform(release, current_version, from_edition = nil, *rspec_args)
+              # When from_edition isn't actually passed but RSpec args arg passed with `-- rspec_args...`,
+              # from_edition is wrongly set to `--`, so we fix that here.
+              if from_edition == "--"
+                rspec_args.prepend('--')
+                from_edition = nil
+              end
+
+              @current_release = QA::Release.new(release)
+              @upgrade_path = Support::GitlabUpgradePath.new(
+                current_version,
+                'from_patch',
+                from_edition || @current_release.edition
+              ).fetch
+              @rspec_args = rspec_args
+
+              # Key difference to UpdateFromPrevious: current_release comes first in the upgrade path
+              upgrade_info = "(#{current_version}) #{[current_release, *upgrade_path].join(' => ')}".bright
+              Runtime::Logger.info("Performing gitlab update: #{upgrade_info}")
+
+              update(rspec_args)
+            end
+
+            private
+
+            # Override to run specs in reverse order - first on development version, then on target version
+            #
+            # @param [Array] rspec_args
+            # @return [void]
+            def update(rspec_args)
+              Docker::Volumes.new.with_temporary_volumes do |volumes|
+                # deploy development release and run specs to populate db
+                Runtime::Logger.info("Running the development release: #{current_release}")
+                run_gitlab(current_release, volumes, seeding_suite_args, seeding_run: true)
+
+                # deploy target release and run tests
+                upgrade_path.each do |release|
+                  Runtime::Logger.info("Upgrading GitLab to target release: #{release}")
+                  run_gitlab(release, volumes, rspec_args, skip_setup: true)
+                end
+              end
+            end
+
+            # Override to run specs on development release and final target
+            #
+            # @param [Gitlab::QA::Release] release
+            # @return [Boolean]
+            def run_specs?(release)
+              [current_release, upgrade_path.last].any?(release)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/qa/support/gitlab_upgrade_path.rb

@@ -13,11 +13,17 @@ module Gitlab
         # @param [String] semver_component version number component for previous version detection - major|minor|patch
         # @param [String] edition GitLab edition - ee or ce
         def initialize(current_version, semver_component, edition)
+          @logger = Runtime::Logger.logger
+
+          unless current_version.match?(GitlabVersionInfo::VERSION_PATTERN)
+            logger.error("Invalid 'current_version' format: #{current_version}. Expected format: MAJOR.MINOR.PATCH (e.g., 17.8.2)")
+            exit 1
+          end
+
           @version_info = GitlabVersionInfo.new(current_version, edition)
-          @current_version = Gem::Version.new(current_version)
+          @current_version = Gem::Version.new(current_version.match(GitlabVersionInfo::VERSION_PATTERN)[:version]) # Extract version without postfixes like pre or ee
           @semver_component = semver_component
           @edition = edition
-          @logger = Runtime::Logger.logger
         end
 
         # Get upgrade path between releases
@@ -26,9 +32,20 @@ module Gitlab
         #
         # @return [Array<QA::Release>]
         def fetch
-          return minor_upgrade_path unless major_upgrade?
-
-          major_upgrade_path
+          case semver_component
+          when "patch"
+            patch_upgrade_path
+          when "minor"
+            minor_upgrade_path
+          when "major"
+            major_upgrade_path
+          when "from_patch"
+            from_patch_upgrade_path
+          when "internal_patch"
+            internal_patch_upgrade_path
+          else
+            raise ArgumentError, "Unknown semver component: #{semver_component}"
+          end
         rescue GitlabVersionInfo::VersionNotFoundError
           logger.error("Failed to construct gitlab upgrade path")
           raise
@@ -40,6 +57,17 @@ module Gitlab
 
         attr_reader :version_info, :current_version, :semver_component, :edition, :logger
 
+        # Upgrade path for patch version update
+        # Returns array with current version as we're testing upgrade from
+        # latest stable patch to development version
+        #
+        # @return [Array]
+        def patch_upgrade_path
+          verify_current_version_exists
+
+          [release(latest_patch(current_version))]
+        end
+
         # Upgrade path from previous minor version
         #
         # @return [Array]
@@ -63,11 +91,84 @@ module Gitlab
           end
         end
 
-        # Upgrade from previous major
+        # Upgrade path from current version to next stable version
+        # Checks if current version exists in releases
+        # Gets next available major.minor version and its latest patch
         #
-        # @return [Boolean]
-        def major_upgrade?
-          semver_component == "major"
+        # @return [Array] Array with next version's latest patch release or exits with message
+        def from_patch_upgrade_path
+          verify_current_version_exists
+          next_version = version_info.next_version(current_version.to_s)
+
+          unless next_version
+            logger.info("Skipping upgrade test as next version after #{current_version} is not yet available")
+            exit 0
+          end
+
+          [release(latest_patch(next_version))]
+        end
+
+        # Upgrade path for internal patch version
+        # Sets up authentication for internal registry
+        # Finds the latest internal build for the current version
+        #
+        # @return [Array<QA::Release>] Array with the latest internal build for current version or exits with message
+        def internal_patch_upgrade_path
+          unless Runtime::Env.dev_access_token_variable
+            logger.error("Skipping upgrade test as internal patch upgrades are not supported without dev access token")
+            exit 0
+          end
+
+          verify_current_version_exists
+          gitlab_int_reg_repo = "dev.gitlab.org:5005/gitlab/omnibus-gitlab/gitlab-ee"
+
+          # Internal releases are stored in private repo and
+          # not available for search with API
+          release = QA::Release.new("#{gitlab_int_reg_repo}:latest")
+          docker = Docker::Engine.new
+          docker.login(**release.login_params) if release.login_params
+          latest_internal_tag = find_latest_internal_tag(gitlab_int_reg_repo, docker)
+
+          if latest_internal_tag
+            [QA::Release.new("#{gitlab_int_reg_repo}:#{latest_internal_tag}")]
+          else
+            logger.warn("No internal image found for GitLab version #{current_version}")
+            exit 0
+          end
+        end
+
+        # Find the latest internal tag for the current version
+        # Searches for tags in descending order, from 10 down to 0
+        # Returns the first available tag or nil if none found
+        #
+        # @param [String] gitlab_int_reg_repo Registry repository path
+        # @param [Docker::Engine] docker_engine Docker engine instance
+        # @return [String, nil] Tag name if found, nil otherwise
+        def find_latest_internal_tag(gitlab_int_reg_repo, docker)
+          # Try to find the highest internal release tag, starting from 10
+          latest_internal_tag = nil
+          logger.info("Start searching for the latest released internal image for gitlab version: #{current_version}...")
+
+          # Release team note: no more than 10 internal releases expected for version
+          10.downto(0) do |internal_num|
+            tag = "#{current_version}-internal#{internal_num}-0"
+            image_uri = "#{gitlab_int_reg_repo}:#{tag}"
+
+            logger.info("Checking for image: #{image_uri}")
+
+            begin
+              # Try to pull the image (this will fail if image doesn't exist)
+              docker.pull(image: gitlab_int_reg_repo, tag: tag)
+
+              latest_internal_tag = tag
+              logger.info("Found image: #{image_uri}")
+              break
+            rescue Support::ShellCommand::StatusError => e
+              logger.info("x - Image not found: #{image_uri}, \n #{e}")
+            end
+          end
+
+          latest_internal_tag
         end
 
         # Docker release image
@@ -85,6 +186,17 @@ module Gitlab
           @previous_version ||= version_info.previous_version(semver_component)
         end
 
+        # Verify if current version exists in GitLab releases
+        # Exit with message if version is not yet released
+        #
+        # @return [void]
+        def verify_current_version_exists
+          return if version_info.version_exists?(current_version.to_s)
+
+          logger.info("Skipping upgrade test as version #{current_version} is not yet released")
+          exit 0
+        end
+
         # Gitlab upgrade path
         #
         # @return [Array<Gem::Version>]

data/lib/gitlab/qa/support/gitlab_version_info.rb

@@ -36,6 +36,18 @@ module Gitlab
           end
         end
 
+        # Check if specific version exists in GitLab releases
+        #
+        # @example
+        # version_exists?("17.10.5") => true
+        # version_exists?("17.10.28") => false
+        #
+        # @param [String] version Version to check
+        # @return [Boolean] true if version exists in GitLab releases, false otherwise
+        def version_exists?(version)
+          !!versions.find { |ver| ver.to_s == version }
+        end
+
         # Get latest patch for specific version number
         #
         # @example
@@ -53,6 +65,27 @@ module Gitlab
           end
         end
 
+        # Get next version major.minor from available releases
+        #
+        # @example
+        # next_version("17.7.4") => "17.8"
+        # next_version("17.12.5") => "18.0"
+        # next_version("18.0.3") => nil # when no next version exists
+        #
+        # @param [String] version Current version
+        # @return [String, nil] Next version in major.minor format or nil if no next version exists
+        def next_version(version)
+          current_ver = Gem::Version.new(version)
+
+          # Since versions are already sorted in descending order (newest first),
+          # we need to reverse them to find the next version after current
+          next_ver = versions.reverse.find { |ver| ver > current_ver }
+
+          return nil unless next_ver
+
+          [next_ver.segments[0], next_ver.segments[1]].join('.') # major.minor
+        end
+
         private
 
         MAX_TAGS_HTTP_REQUESTS = 50

data/lib/gitlab/qa/version.rb

@@ -2,6 +2,6 @@
 
 module Gitlab
   module QA
-    VERSION = '15.2.0'
+    VERSION = '15.4.0'
   end
 end

data/support/pipeline/create_for_projectname.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class CreateForProjectname
+  class << self
+    def create_pipeline
+      project_name = ENV.fetch('PROJECT_NAME', nil)
+      root_user = User.find_by_username('root')
+      project = Project.find_by_path(project_name)
+
+      if project
+        pipeline_service = Ci::CreatePipelineService.new(project, root_user, ref: project.default_branch_or_main)
+        pipeline = pipeline_service.execute(:api)
+
+        if pipeline
+          puts "Pipeline created successfully. Pipeline ID: \#{pipeline.payload.id}"
+        else
+          puts "Failed to create pipeline"
+          exit 1
+        end
+      else
+        puts "Project not found: \#{project_name}"
+        exit 1
+      end
+    end
+  end
+end
+
+CreateForProjectname.create_pipeline

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-qa
 version: !ruby/object:Gem::Version
-  version: 15.2.0
+  version: 15.4.0
 platform: ruby
 authors:
 - GitLab Quality
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-26 00:00:00.000000000 Z
+date: 2025-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -407,15 +407,19 @@ files:
 - lib/gitlab/qa/component/gitlab.rb
 - lib/gitlab/qa/component/jira.rb
 - lib/gitlab/qa/component/ldap.rb
+- lib/gitlab/qa/component/license_ops.rb
 - lib/gitlab/qa/component/mail_hog.rb
 - lib/gitlab/qa/component/minio.rb
 - lib/gitlab/qa/component/mock_server.rb
 - lib/gitlab/qa/component/opensearch.rb
+- lib/gitlab/qa/component/pipeline_ops.rb
 - lib/gitlab/qa/component/postgresql.rb
 - lib/gitlab/qa/component/praefect.rb
 - lib/gitlab/qa/component/preprod.rb
 - lib/gitlab/qa/component/production.rb
+- lib/gitlab/qa/component/project_importer.rb
 - lib/gitlab/qa/component/release.rb
+- lib/gitlab/qa/component/runner_ops.rb
 - lib/gitlab/qa/component/saml.rb
 - lib/gitlab/qa/component/selenoid.rb
 - lib/gitlab/qa/component/specs.rb
@@ -452,6 +456,7 @@ files:
 - lib/gitlab/qa/scenario/test/instance/relative_url.rb
 - lib/gitlab/qa/scenario/test/instance/release.rb
 - lib/gitlab/qa/scenario/test/instance/repository_storage.rb
+- lib/gitlab/qa/scenario/test/instance/secure_version.rb
 - lib/gitlab/qa/scenario/test/instance/smoke.rb
 - lib/gitlab/qa/scenario/test/instance/staging.rb
 - lib/gitlab/qa/scenario/test/instance/staging_ref.rb
@@ -493,6 +498,7 @@ files:
 - lib/gitlab/qa/scenario/test/omnibus/image.rb
 - lib/gitlab/qa/scenario/test/omnibus/update_from_previous.rb
 - lib/gitlab/qa/scenario/test/omnibus/update_from_previous_ai.rb
+- lib/gitlab/qa/scenario/test/omnibus/update_to_next.rb
 - lib/gitlab/qa/scenario/test/omnibus/upgrade.rb
 - lib/gitlab/qa/service/cluster_provider/base.rb
 - lib/gitlab/qa/service/cluster_provider/k3d.rb
@@ -516,6 +522,7 @@ files:
 - support/manifests/suggested_reviewer/pubsub.yaml
 - support/manifests/suggested_reviewer/recommender-bot.yaml
 - support/manifests/suggested_reviewer/recommender.yaml
+- support/pipeline/create_for_projectname.rb
 - support/setup/gitlab_duo_setup.rb
 - tls_certificates/authority/ca.crt
 - tls_certificates/authority/ca.key
@@ -549,7 +556,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Integration tests for GitLab