gitlab-qa 0.2.2 → 0.3.0

data/README.md

@@ -25,6 +25,10 @@ command in your system.
 
     `gitlab-qa Test::Instance::Image CE|EE|<full image address>`
 
+1. Run tests against a Docker image with GitLab and Mattermost:
+
+    `gitlab-qa Test::Integration::Mattermost CE|EE|<full image address>`
+
 1. Test upgrade process:
 
     `gitlab-qa Test::Omnibus::Upgrade CE|EE|<full image address>`
@@ -61,16 +65,29 @@ This scenario tests that the GitLab Docker container works as expected by
 running tests against it.
 
 To run tests against the GitLab containers, a GitLab QA (`gitlab/gitlab-qa`)
-container is spin up and tests are run from it by running the `Test::Instance`
+container is spun up and tests are run from it by running the `Test::Instance`
 scenario (located under `qa/scenario/test/instance` in the GitLab codebase).
 
+### `Test::Integration::Mattermost CE|EE|<full image address>`
+
+This scenario tests that GitLab instance works as expected when
+enabling the embedded Mattermost server (see `Test::Instance::Image`
+above).
+
 ### `Test::Instance::Any CE|EE|<full image address>`
 
 This scenario tests that the any GitLab instance works as expected by running
-tests against it (see `Test::Instance::Image` below).
+tests against it (see `Test::Instance::Image` above).
 
 ## Supported environment variables
 
 * `GITLAB_USERNAME` - username to use when signing in to GitLab
-* `GITLAB_PASSWORD`  - password to use when signing in to GitLab
+* `GITLAB_PASSWORD` - password to use when signing in to GitLab
 * `EE_LICENSE` - Enterprise Edition license
+* `QA_SCREENSHOTS_DIR` - Path to a directory where screenshots for failing tests
+  will be saved (default: `/tmp/gitlab-qa-screenshots`)
+* `DOCKER_HOST` - Docker host to run tests against (default: `http://localhost`)
+
+## Contributing
+
+Please see the [contribution guidelines](CONTRIBUTING.md)

data/lib/gitlab/qa.rb

@@ -22,14 +22,22 @@ module Gitlab
           autoload :Image, 'qa/scenario/test/omnibus/image'
           autoload :Upgrade, 'qa/scenario/test/omnibus/upgrade'
         end
+
+        module Integration
+          autoload :Mattermost, 'qa/scenario/test/integration/mattermost'
+        end
       end
     end
 
+    module Component
+      autoload :Gitlab, 'qa/component/gitlab'
+      autoload :Specs, 'qa/component/specs'
+    end
+
     module Docker
       autoload :Engine, 'qa/docker/engine'
       autoload :Command, 'qa/docker/command'
-      autoload :Gitlab, 'qa/docker/gitlab'
-      autoload :Specs, 'qa/docker/specs'
+      autoload :Shellout, 'qa/docker/shellout'
     end
   end
 end

data/lib/gitlab/qa/{docker → component}/gitlab.rb

@@ -1,28 +1,42 @@
 require 'securerandom'
 require 'net/http'
 require 'uri'
+require 'forwardable'
+require 'shellwords'
 
 module Gitlab
   module QA
-    module Docker
+    module Component
       class Gitlab
+        extend Forwardable
         include Scenario::Actable
 
         # rubocop:disable Style/Semicolon
 
-        attr_accessor :image, :tag, :volumes, :network
-        attr_reader :name, :release
+        attr_reader :release, :docker
+        attr_accessor :volumes, :network, :environment, :network_aliases
+
+        def_delegators :release, :tag, :image, :edition
 
         def initialize
           @docker = Docker::Engine.new
+          @environment = {}
+          @volumes = {}
+          @network_aliases = []
+
+          self.release = 'CE'
         end
 
-        def name=(name)
-          @name = "#{name}-#{SecureRandom.hex(4)}"
+        def omnibus_config=(config)
+          @environment['GITLAB_OMNIBUS_CONFIG'] = config
         end
 
         def release=(release)
-          @release ||= Release.new(release)
+          @release = Release.new(release)
+        end
+
+        def name
+          @name ||= "gitlab-qa-#{edition}-#{SecureRandom.hex(4)}"
         end
 
         def address
@@ -30,7 +44,7 @@ module Gitlab
         end
 
         def hostname
-          "#{@name}.#{@network}"
+          "#{name}.#{network}"
         end
 
         def instance
@@ -44,29 +58,40 @@ module Gitlab
         end
 
         def prepare
-          @docker.pull(@image, @tag)
+          @docker.pull(image, tag)
 
-          return if @docker.network_exists?(@network)
-          @docker.network_create(@network)
+          return if @docker.network_exists?(network)
+          @docker.network_create(network)
         end
 
+        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/AbcSize
         def start
-          unless [@name, @image, @tag, @network].all?
-            raise 'Please configure an instance first!'
-          end
+          ensure_configured!
 
-          @docker.run(@image, @tag) do |command|
-            command << "-d --name #{@name} -p 80:80"
-            command << "--net #{@network} --hostname #{hostname}"
+          docker.run(image, tag) do |command|
+            command << '-d -p 80:80'
+            command << "--name #{name}"
+            command << "--net #{network}"
+            command << "--hostname #{hostname}"
 
             @volumes.to_h.each do |to, from|
               command << "--volume #{to}:#{from}:Z"
             end
+
+            @environment.to_h.each do |key, value|
+              escaped_value = Shellwords.escape(value)
+              command << "--env #{key}=#{escaped_value}"
+            end
+
+            @network_aliases.to_a.each do |network_alias|
+              command << "--network-alias #{network_alias}"
+            end
           end
         end
 
         def reconfigure
-          @docker.attach(@name) do |line, wait|
+          @docker.attach(name) do |line, wait|
             # TODO, workaround which allows to detach from the container
             #
             Process.kill('INT', wait.pid) if line =~ /gitlab Reconfigured!/
@@ -74,14 +99,14 @@ module Gitlab
         end
 
         def restart
-          @docker.restart(@name)
+          @docker.restart(name)
         end
 
         def teardown
-          raise 'Invalid instance name!' unless @name
+          raise 'Invalid instance name!' unless name
 
-          @docker.stop(@name)
-          @docker.remove(@name)
+          @docker.stop(name)
+          @docker.remove(name)
         end
 
         def wait
@@ -96,6 +121,15 @@ module Gitlab
           end
         end
 
+        private
+
+        # rubocop:disable Style/GuardClause
+        def ensure_configured!
+          unless [name, release, network].all?
+            raise 'Please configure an instance first!'
+          end
+        end
+
         class Availability
           def initialize(address)
             @uri = URI.join(address, '/help')

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

@@ -0,0 +1,59 @@
+module Gitlab
+  module QA
+    module Component
+      ##
+      # This class represents GitLab QA specs image that is implemented in
+      # the `qa/` directory located in GitLab CE / EE repositories.
+      #
+      # TODO, it needs some refactoring.
+      #
+      class Specs
+        include Scenario::Actable
+
+        IMAGE_NAME = 'gitlab/gitlab-qa'.freeze
+
+        def initialize
+          @docker = Docker::Engine.new
+        end
+
+        def test(gitlab:, suite: 'Test::Instance', extra_args: [])
+          test_address(
+            release: gitlab.release,
+            address: gitlab.address,
+            name: "#{gitlab.name}-specs",
+            network: gitlab.network,
+            suite: suite,
+            extra_args: extra_args
+          )
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def test_address(release:, address:, name: nil, network: nil,
+                         suite: 'Test::Instance', extra_args: [])
+          puts "Running instance suite #{suite} for Gitlab " \
+               "#{release.edition.upcase} at #{address}"
+
+          args = [suite, address] + extra_args
+
+          @docker.run(IMAGE_NAME, release.edition_tag, *args) do |command|
+            build_command(command, name, network)
+          end
+        end
+
+        private
+
+        def build_command(command, name, network)
+          command << "-t --rm --net=#{network || 'bridge'}"
+
+          Runtime::Env.delegated.each do |env|
+            command.env(env, "$#{env}")
+          end
+
+          command.volume('/var/run/docker.sock', '/var/run/docker.sock')
+          command.volume(Runtime::Env.screenshots_dir, '/home/qa/tmp')
+          command.name(name || "gitlab-specs-#{Time.now.to_i}")
+        end
+      end
+    end
+  end
+end

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

@@ -1,17 +1,9 @@
-require 'open3'
-
 module Gitlab
   module QA
     module Docker
       class Command
-        class StatusError < StandardError; end
-
         attr_reader :args
 
-        def self.execute(cmd, &block)
-          new(cmd).execute!(&block)
-        end
-
         def initialize(cmd = nil)
           @args = Array(cmd)
         end
@@ -20,25 +12,28 @@ module Gitlab
           tap { @args.concat(args) }
         end
 
-        def execute!(&block)
-          engine("docker #{@args.join(' ')}", &block)
+        def volume(from, to)
+          tap { @args << "-v #{from}:#{to}" }
         end
 
-        private
+        def name(identity)
+          tap { @args << "--name #{identity}" }
+        end
 
-        def engine(cmd)
-          puts "Running shell command: `#{cmd}`"
+        def env(name, value)
+          tap { @args << %(-e #{name}="#{value}") }
+        end
 
-          Open3.popen2e(cmd) do |_in, out, wait|
-            out.each do |line|
-              puts line
-              yield line, wait if block_given?
-            end
+        def to_s
+          "docker #{@args.join(' ')}"
+        end
 
-            if wait.value.exited? && wait.value.exitstatus.nonzero?
-              raise StatusError, "Docker command `#{cmd}` failed!"
-            end
-          end
+        def execute!(&block)
+          Docker::Shellout.execute!(self, &block)
+        end
+
+        def self.execute(cmd, &block)
+          new(cmd).execute!(&block)
         end
       end
     end

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

@@ -41,7 +41,7 @@ module Gitlab
 
         def network_exists?(name)
           Docker::Command.execute("network inspect #{name}")
-        rescue Docker::Command::StatusError
+        rescue Docker::Shellout::StatusError
           false
         else
           true

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

@@ -0,0 +1,27 @@
+require 'open3'
+
+module Gitlab
+  module QA
+    module Docker
+      class Shellout
+        class StatusError < StandardError; end
+
+        def self.execute!(command)
+          puts "Running shell command: `#{command}`"
+
+          Open3.popen2e(command.to_s) do |_in, out, wait|
+            out.each do |line|
+              puts line
+
+              yield line, wait if block_given?
+            end
+
+            if wait.value.exited? && wait.value.exitstatus.nonzero?
+              raise StatusError, "Docker command `#{command}` failed!"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/qa/release.rb

@@ -5,33 +5,55 @@ module Gitlab
       DEFAULT_TAG = 'nightly'.freeze
 
       attr_reader :release
+      attr_writer :tag
 
       def initialize(release)
         @release = release.to_s
       end
 
+      def to_s
+        "#{image}:#{tag}"
+      end
+
+      def previous_stable
+        # The previous stable is always gitlab/gitlab-ce:latest or
+        # gitlab/gitlab-ee:latest
+        self.class.new("#{canonical_image}:latest")
+      end
+
       def edition
-        if canonical?
-          release.downcase.to_sym
-        else
-          release.match(CUSTOM_GITLAB_IMAGE_REGEX)[1].to_sym
-        end
+        @edition ||=
+          if canonical?
+            release.downcase.to_sym
+          else
+            release.match(CUSTOM_GITLAB_IMAGE_REGEX)[1].to_sym
+          end
       end
 
       def image
-        if canonical?
-          "gitlab/gitlab-#{edition}"
-        else
-          release.sub(/:.+\z/, '')
-        end
+        @image ||=
+          if canonical?
+            "gitlab/gitlab-#{edition}"
+          else
+            release.sub(/:.+\z/, '')
+          end
+      end
+
+      def canonical_image
+        @canonical_image ||= "gitlab/gitlab-#{edition}"
       end
 
       def tag
-        if canonical?
-          DEFAULT_TAG
-        else
-          release.match(CUSTOM_GITLAB_IMAGE_REGEX)[2]
-        end
+        @tag ||=
+          if canonical?
+            DEFAULT_TAG
+          else
+            release.match(CUSTOM_GITLAB_IMAGE_REGEX)[2]
+          end
+      end
+
+      def edition_tag
+        @edition_tag ||= "#{edition}-#{tag}"
       end
 
       private

data/lib/gitlab/qa/runtime/env.rb

@@ -4,12 +4,17 @@ module Gitlab
       module Env
         extend self
 
+        VARIABLES = %w(GITLAB_USERNAME
+                       GITLAB_PASSWORD
+                       GITLAB_URL
+                       EE_LICENSE).freeze
+
         def screenshots_dir
           ENV['QA_SCREENSHOTS_DIR'] || '/tmp/gitlab-qa-screenshots'
         end
 
         def delegated
-          %w(GITLAB_USERNAME GITLAB_PASSWORD GITLAB_URL EE_LICENSE).freeze
+          VARIABLES.select { |name| ENV[name] }
         end
       end
     end