gitlab-qa 6.21.3 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b108747b63e44e62bb63b71823e9612f8e32d652713bea427495a2139b61033
-  data.tar.gz: 75b2b9a6ea4ead609c242046b621d4360d192bb9bd8b4da50df8e90a62b38adf
+  metadata.gz: ce83d37d177260e577ff1ffbc8e606eab4bc449953d8fc9de669404371433014
+  data.tar.gz: ef2a8ba114e9799c4d8b4cc71f3c098ac708b79e8573486305b9802d6bdf1826
 SHA512:
-  metadata.gz: 83abd37be38747a36a6c96b23af631df6b878ccc70ac1d2a496acd04dfdef8eb99fd8afc148935269b86b6ba937037b58003f0f53fd979404df76343f15f3d1d
-  data.tar.gz: 996f450bafb008395fbbb6f46afc9d12f6a7ac07d4451a039c57959e983c6eb6b77230144be052e16064990105611af713e2e166f69aa2392eccb3b048e32ed7
+  metadata.gz: 22d88835fee7158e9e5829e5d5e415abfa85d157148514c21eb904eecf69a8e8c4a49dc6e3aaae0e35824fc8f3a2be2d0c983f2f8057c915bcd0332a2fbea41f
+  data.tar.gz: 6e8007813c6258741ba516b011b8a5fc7efa1ee1ada5c385580477a18b02c35ac8e232370a80395fd3259f98058abaaffe11941c7ec9f8108a19dd36aafa4df3

data/.gitlab-ci.yml

@@ -12,13 +12,14 @@ default:
   cache:
     key:
       files:
-        - Gemfile
+        - Gemfile.lock
         - gitlab-qa.gemspec
     paths:
       - vendor/ruby
   before_script:
     - bundle version
-    - bundle install --clean --jobs=$(nproc) --path=vendor --retry=3 --quiet && bundle check
+    - bundle config path vendor
+    - bundle install --jobs=$(nproc) --retry=3 --quiet && bundle check
     - if [ -n "$TRIGGERED_USER" ] && [ -n "$TRIGGER_SOURCE" ]; then
         echo "Pipeline triggered by $TRIGGERED_USER at $TRIGGER_SOURCE";
       fi

data/docs/configuring_omnibus.md

@@ -0,0 +1,208 @@
+# Configuring Omnibus
+
+Omnibus will, by default, contain the configuration specified in `Gitlab::QA::Runtime::OmnibusConfigurations::Default`.
+
+Omnibus can be configured from two places:
+
+1. Within a custom `Scenario::Template`.
+1. Represented as a `Gitlab::QA::Runtime::OmnibusConfiguration` class.
+
+## Adding an Omnibus Configurator
+
+All configurators are held within `Gitlab::QA::Runtime::OmnibusConfigurations` and represented as separate classes.
+
+Notes:
+
+- If it is required that more than one GitLab instance is configured, 
+  you may skip adding an Omnibus Configurator.  In this case, it should be handled by a separate `Scenario::Template`.
+  An example of this would be a Geo Primary and Secondary.
+- All classes should be a type of `Runtime::OmnibusConfiguration`.
+
+### Add the Configurator Class
+
+Create a new file in `lib/gitlab/qa/runtime/omnibus_configurations` called `registry.rb`.
+
+```ruby
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Runtime
+      module OmnibusConfigurations
+        class Registry < Default
+          def configuration
+            <<~OMNIBUS
+              gitlab_rails['registry_enabled'] = true
+            OMNIBUS
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+Notes:
+
+- Refrain from adding unnecessary statement terminations (`;`).
+
+### Prepare Sidecar Container
+
+If the tests require an additional container to be spun up adjacent to GitLab, you may override the `prepare` method.
+
+```ruby
+#=> lib/gitlab/qa/runtime/omnibus_configurations/registry.rb
+
+# frozen_string_literal: true
+
+module Gitlab
+  module QA
+    module Runtime
+      module OmnibusConfigurations
+        class Registry < Default
+          def configuration
+            <<~OMNIBUS
+              gitlab_rails['registry_enabled'] = true
+            OMNIBUS
+          end
+
+          def prepare
+            Component::Sidecar.new
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+Notes:
+
+- `prepare` **must** return an instance of `Component::Base`.
+- The sidecar container will be prepared before the test runs, and will run the tests after it is running.
+- Extending the class from `Default` is only a nicety that adds a singleton method called `Registry.configuration` and returns the configuration.
+  It is recommended to extend from `Default`, but you may also extend from any other Omnibus Configuration class, including `Runtime::OmnibusConfiguration`.
+
+## Running tests with Omnibus Configured
+
+All Omnibus Configurators can be called by passing arguments into the `gitlab-qa` executable.
+
+```shell
+exe/gitlab-qa Test::Instance::Image EE --omnibus-config registry
+```
+
+Notes:
+
+- `--omnibus-config registry` must match the name of the Omnibus Configurator Class name (`Runtime::OmnibusConfigurations::Registry`), but lowercase.
+- If the Configurator Class name contains several words, the argument will be named the same, but snake cased. E.g. `--omnibus-config some_class` matches `SomeClass`, `--omnibus-config some_other_class` matches `SomeOtherClass`.
+- The Omnibus GitLab Instance will have the configuration from `Default` and `Registry` (in that order) put into `/etc/gitlab/gitlab.rb` and GitLab QA will proceed to run the tests.
+- If a specified Omnibus Configuration does not exist, GitLab QA will raise an error and fail immediately.
+
+## Further reading
+
+### Multiple Configurators
+
+Multiple Configurators may be specified and the order will be preserved in which the arguments were passed.
+
+E.g., given the arguments:
+
+```
+exe/gitlab-qa Test::Instance::Image EE --omnibus-config packages,registry
+# or
+exe/gitlab-qa Test::Instance::Image EE --omnibus-config packages --omnibus-config registry
+```
+
+Omnibus will be configured in the order they appear.
+
+```ruby
+# /etc/gitlab/gitlab.rb
+#=> Runtime::OmnibusConfiguration::Default#configuration
+#=> Runtime::OmnibusConfiguration::Packages#configuration
+#=> Runtime::OmnibusConfiguration::Registry#configuration
+```
+
+The order is also preserved for Sidecar containers.  If the `Packages` and `Registry` Configurators each prepare a sidecar container, they will be spun up in order from first to last.
+
+### Adding one-off configurations
+
+#### From a new Scenario::Template
+
+If it is required to create a new `Scenario::Template`, you may add new Configurations to the respective GitLab Instances by invoking `omnibus_configuration#<<`
+
+```ruby
+# Geo example
+
+Component::Gitlab.perform do |primary|
+  primary.omnibus_configuration << <<~OMNIBUS
+    geo_primary_role['enable'] = true
+  OMNIBUS
+  
+  primary.instance do
+    Component::Gitlab.perform do |secondary|
+      secondary.omnibus_configuration << <<~OMNIBUS
+        geo_secondary_role['enable'] = true
+      OMNIBUS
+    end
+  end
+end
+```
+
+Notes:
+
+- The `primary` instance will be configured using the `Runtime::OmnibusConfigurations::Default` configuration, *then* `geo_primary_role['enable'] = true` will be affixed afterwards.
+- The `secondary` instance will be configured using the `Runtime::OmnibusConfigurations::Default` configuration, *then* `geo_secondary_role['enable'] = true` will be affixed afterwards.
+
+#### From Component::Gitlab
+
+Any additional one-off configurations needing to be added may be directly appended to `@omnibus_configuration` as such:
+
+```ruby
+disable_animations = true
+
+@omnibus_configuration << "gitlab_rails['gitlab_disable_animations'] = true" if disable_animations
+```
+
+This will add the specified configuration **after** what has already been specified beforehand (Configurators or Default configurations).
+
+Note:
+
+- If there is no issue appending this configuration to the **rest** of the GitLab Instances that might be spun up, you can add this
+  to the global Omnibus Configuration. E.g., use `Runtime::Scenario.omnibus_configuration << ...` instead of `@omnibus_configuration << ...`
+
+#### Difference between Runtime::Scenario.omnibus_configuration and Gitlab#omnibus_configuration
+
+Generally, while running GitLab QA, only one GitLab instance is necessary. `Runtime::Scenario.omnibus_configuration` contains all of the global
+Omnibus configurations required for this one environment.  This also contains the configuration for any other GitLab instance.
+
+When multiple GitLab Instances are required, `@omnibus_configuration#<<` is preferred over `Runtime::Scenario.omnibus_configuration#<<` since the First Instance might require
+one Omnibus configuration that might be unneccesary or Invalid for the Second Instance.
+
+#### Load order and precedence
+
+1. `Runtime::OmnibusConfigurations::Default`
+1. `Runtime::OmnibusConfigurations::[A,B,...]` where `A` and `B` are Configurators specified through the positional arguments `--a --b`
+1. Custom written `Scenario::Template` (such as `Test::Integation::Geo`)
+1. `lib/gitlab/qa/component/gitlab.rb`
+
+From top to bottom, configurations will be loaded and any configurations that are superceded, will take precedence over the one before it, and so on.
+
+### Executing arbitrary shell commands within the GitLab Instance
+
+Sometimes it's necessary to execute arbitrary commands within the GitLab instance before the tests start.
+
+You may specify these commands by overriding the `exec_commands` method within the Configurator.
+
+```ruby
+class Registry < Default
+  def configuration
+    # configuration
+  end
+  
+  def exec_commands
+    [
+      'cp /etc/gitlab/gitlab.rb /etc/gitlab/gitlab.bak.rb',
+      'rm /etc/gitlab/gitlab.bak.rb'
+    ]
+  end
+end
+```

data/docs/run_qa_against_gdk.md

@@ -37,6 +37,10 @@ make a few changes to your `gdk/gitlab/config/gitlab.yml` file.
   # build the QA image first
   # In gdk/gitlab:
   $ docker build -t gitlab/gitlab-ce-qa:your-custom-tag --file ./qa/Dockerfile ./
+  
+  # Note: You will also need a corresponding GitLab image. 
+  # For example, if you haven't changed any application code (e.g., no new elements), you could tag the current nightly build:
+  $ docker tag gitlab/gitlab-ce:nightly gitlab/gitlab-ce:your-custom-tag
 
   # Then in gitlab-qa:
   $ exe/gitlab-qa Test::Instance::Any gitlab/gitlab-ce:your-custom-tag http://192.168.0.12:3000 -- qa/specs/features/browser_ui/1_manage/login/log_in_spec.rb

data/docs/what_tests_can_be_run.md

@@ -143,6 +143,40 @@ To run EE tests, the `EE_LICENSE` environment variable needs to be set:
 
 `$ export EE_LICENSE=$(cat /path/to/GitLab.gitlab_license)`
 
+## Specifying the GitLab QA image to use
+
+By default, `gitlab-qa` infers the QA image to use based on the GitLab image.
+For instance, if you run the following:
+
+```
+$ gitlab-qa Test::Instance::Image gitlab/gitlab-ee:12.4.0-ee.0
+```
+
+Then, `gitlab-qa` would infer `gitlab/gitlab-ee-qa:12.4.0-ee.0` as the QA image
+based on the GitLab image (note the `-qa` suffix in the image name).
+
+In some cases, you'll want to use a specific QA image instead of letting
+`gitlab-qa` infer the QA image name from the GitLab image. Such cases can be
+when you're doing local debugging/testing and you want to control the QA image
+name, or in the CI where the QA image might be built by a project (e.g.
+`gitlab-org/gitlab`, and the GitLab image might be built by another project
+(e.g. `gitlab-org/omnibus-gitlab-mirror`).
+
+To specify the QA image to use, pass the `--qa-image QA_IMAGE` option,
+as follows:
+
+```
+$ gitlab-qa Test::Instance::Image --qa-image registry.gitlab.com/gitlab-org/gitlab/gitlab-ee-qa:branch-name EE
+```
+
+Additionally, setting the `$QA_IMAGE` environment variable achieve the same result,
+without needing to pass the `--qa-image` option:
+
+```
+$ export QA_IMAGE="registry.gitlab.com/gitlab-org/gitlab/gitlab-ee-qa:branch-name"
+$ gitlab-qa Test::Instance::Image EE
+```
+
 ## Running a specific test (or set of tests)
 
 In most of the scenarios listed below, if you don't want to run all the tests

data/gitlab-qa.gemspec

@@ -31,5 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'gitlab', '~> 4.16.1'
   spec.add_runtime_dependency 'http', '4.3.0'
   spec.add_runtime_dependency 'nokogiri', '~> 1.10'
-  spec.add_runtime_dependency 'table_print', '1.5.6'
+  spec.add_runtime_dependency 'table_print', '1.5.7'
 end

data/lib/gitlab/qa.rb

@@ -8,6 +8,13 @@ module Gitlab
       autoload :Env, 'gitlab/qa/runtime/env'
       autoload :Scenario, 'gitlab/qa/runtime/scenario'
       autoload :TokenFinder, 'gitlab/qa/runtime/token_finder'
+      autoload :OmnibusConfiguration, 'gitlab/qa/runtime/omnibus_configuration'
+
+      module OmnibusConfigurations
+        autoload :Default, 'gitlab/qa/runtime/omnibus_configurations/default'
+        autoload :Packages, 'gitlab/qa/runtime/omnibus_configurations/packages'
+        autoload :ObjectStorage, 'gitlab/qa/runtime/omnibus_configurations/object_storage'
+      end
     end
 
     module Scenario

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 require 'net/http'
 require 'uri'
@@ -10,38 +12,36 @@ module Gitlab
       class Gitlab < Base
         extend Forwardable
 
-        attr_reader :release
-        attr_accessor :tls, :disable_animations, :skip_availability_check, :runner_network
+        attr_reader :release, :omnibus_configuration
+        attr_accessor :tls, :skip_availability_check, :runner_network
         attr_writer :name, :relative_path
 
         def_delegators :release, :tag, :image, :edition
 
-        GITLAB_CERTIFICATES_PATH = File.expand_path('../../../../tls_certificates/gitlab'.freeze, __dir__)
-        GITALY_CERTIFICATES_PATH = File.expand_path('../../../../tls_certificates/gitaly/ssl'.freeze, __dir__)
-        TRUSTED_CERTIFICATES_PATH = File.expand_path('../../../../tls_certificates/gitaly/trusted-certs'.freeze, __dir__)
+        AUTHORITY_CERTIFICATES_PATH = File.expand_path('../../../../tls_certificates/authority', __dir__)
+        GITLAB_CERTIFICATES_PATH = File.expand_path('../../../../tls_certificates/gitlab', __dir__)
+        GITALY_CERTIFICATES_PATH = File.expand_path('../../../../tls_certificates/gitaly', __dir__)
 
-        SSL_PATH = '/etc/gitlab/ssl'.freeze
-        TRUSTED_PATH = '/etc/gitlab/trusted-certs'.freeze
+        SSL_PATH = '/etc/gitlab/ssl'
+        TRUSTED_PATH = '/etc/gitlab/trusted-certs'
 
         def initialize
           super
 
-          @disable_animations = true
           @skip_availability_check = false
 
           @volumes[GITLAB_CERTIFICATES_PATH] = SSL_PATH
+          @volumes[AUTHORITY_CERTIFICATES_PATH] = TRUSTED_PATH
 
-          self.release = 'CE'
-        end
+          @omnibus_configuration ||= OmnibusConfiguration.new
 
-        def omnibus_config=(config)
-          @environment['GITLAB_OMNIBUS_CONFIG'] = config.tr("\n", ' ')
+          self.release = 'CE'
         end
 
         def set_formless_login_token
           return if Runtime::Env.gitlab_qa_formless_login_token.to_s.strip.empty?
 
-          @environment['GITLAB_OMNIBUS_CONFIG'] = "gitlab_rails['env'] = { 'GITLAB_QA_FORMLESS_LOGIN_TOKEN' => '#{Runtime::Env.gitlab_qa_formless_login_token}' }; #{@environment['GITLAB_OMNIBUS_CONFIG'] || ''}"
+          @omnibus_configuration << "gitlab_rails['env'] = { 'GITLAB_QA_FORMLESS_LOGIN_TOKEN' => '#{Runtime::Env.gitlab_qa_formless_login_token}' }"
         end
 
         def elastic_url=(url)
@@ -68,14 +68,9 @@ module Gitlab
           tls ? '443' : '80'
         end
 
-        def mtls
+        def gitaly_tls
           @volumes.delete(GITLAB_CERTIFICATES_PATH)
           @volumes[GITALY_CERTIFICATES_PATH] = SSL_PATH
-          set_trusted_certificates
-        end
-
-        def set_trusted_certificates
-          @volumes[TRUSTED_CERTIFICATES_PATH] = TRUSTED_PATH
         end
 
         def relative_path
@@ -99,17 +94,7 @@ module Gitlab
         end
 
         def prepare_gitlab_omnibus_config
-          setup_disable_animations if disable_animations
           set_formless_login_token
-          setup_application_settings_cache_expiry
-        end
-
-        def setup_disable_animations
-          @environment['GITLAB_OMNIBUS_CONFIG'] = "gitlab_rails['gitlab_disable_animations'] = true; #{@environment['GITLAB_OMNIBUS_CONFIG'] || ''}"
-        end
-
-        def setup_application_settings_cache_expiry
-          @environment['GITLAB_OMNIBUS_CONFIG'] = "gitlab_rails['application_settings_cache_seconds'] = 0; #{@environment['GITLAB_OMNIBUS_CONFIG'] || ''}"
         end
 
         def start # rubocop:disable Metrics/AbcSize
@@ -139,6 +124,8 @@ module Gitlab
         end
 
         def reconfigure
+          setup_omnibus
+
           @docker.attach(name) do |line, wait|
             puts line
             # TODO, workaround which allows to detach from the container
@@ -150,7 +137,7 @@ module Gitlab
         def wait_until_ready
           return if skip_availability_check
 
-          if Availability.new(name, relative_path: relative_path, scheme: scheme, protocol_port: port.to_i).check(300)
+          if Availability.new(name, relative_path: relative_path, scheme: scheme, protocol_port: port.to_i).check(Runtime::Env.gitlab_availability_timeout)
             sleep 12 # TODO, handle that better
             puts ' -> GitLab is available.'
           else
@@ -174,6 +161,12 @@ module Gitlab
           raise 'Please configure an instance first!' unless [name, release, network].all?
         end
 
+        def setup_omnibus
+          @docker.write_files(name) do |f|
+            f.write('/etc/gitlab/gitlab.rb', @omnibus_configuration.to_s)
+          end
+        end
+
         class Availability
           def initialize(name, relative_path: '', scheme: 'http', protocol_port: 80)
             @docker = Docker::Engine.new
@@ -213,6 +206,20 @@ module Gitlab
             @uri.scheme == 'https' ? { use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE } : {}
           end
         end
+
+        class OmnibusConfiguration
+          def initialize
+            @config = Runtime::Scenario.attributes[:omnibus_configuration] || []
+          end
+
+          def <<(configuration)
+            @config << configuration
+          end
+
+          def to_s
+            @config.to_s
+          end
+        end
       end
     end
   end