chemlab 0.0.1

data/qa/runtime/search.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module QA
+  module Runtime
+    module Search
+      extend self
+      extend Support::Api
+
+      ElasticSearchServerError = Class.new(RuntimeError)
+
+      def assert_elasticsearch_responding
+        QA::Runtime::Logger.debug("Attempting to search via Elasticsearch...")
+
+        QA::Support::Retrier.retry_on_exception(max_attempts: 3) do
+          search_term = SecureRandom.hex(8)
+
+          QA::Runtime::Logger.debug("Creating commit and project including search term '#{search_term}'...")
+
+          content = "Elasticsearch test commit #{search_term}"
+          project = Resource::Project.fabricate_via_api! do |project|
+            project.name = "project-to-search-#{search_term}"
+          end
+          commit = Resource::Repository::Commit.fabricate_via_api! do |commit|
+            commit.project = project
+            commit.commit_message = content
+            commit.add_files(
+              [
+                {
+                  file_path: 'test.txt',
+                  content: content
+                }
+              ]
+            )
+          end
+
+          verify_search_engine_ok(search_term)
+
+          find_commit(commit, "commit*#{search_term}")
+          find_project(project, "to-search*#{search_term}")
+        end
+      end
+
+      def elasticsearch_on?(api_client)
+        elasticsearch_state_request = Runtime::API::Request.new(api_client, '/application/settings')
+        response = get elasticsearch_state_request.url
+
+        parse_body(response)[:elasticsearch_search] && parse_body(response)[:elasticsearch_indexing]
+      end
+
+      def disable_elasticsearch(api_client)
+        disable_elasticsearch_request = Runtime::API::Request.new(api_client, '/application/settings')
+        put disable_elasticsearch_request.url, elasticsearch_search: false, elasticsearch_indexing: false
+      end
+
+      def create_search_request(api_client, scope, search_term)
+        Runtime::API::Request.new(api_client, '/search', scope: scope, search: search_term)
+      end
+
+      def find_code(file_name, search_term)
+        find_target_in_scope('blobs', search_term) do |record|
+          record[:filename] == file_name && record[:data].include?(search_term)
+        end
+
+        QA::Runtime::Logger.debug("Found file '#{file_name} containing code '#{search_term}'")
+      end
+
+      def find_commit(commit, search_term)
+        find_target_in_scope('commits', search_term) do |record|
+          record[:message] == commit.commit_message
+        end
+
+        QA::Runtime::Logger.debug("Found commit '#{commit.commit_message} (#{commit.short_id})' via '#{search_term}'")
+      end
+
+      def find_project(project, search_term)
+        find_target_in_scope('projects', search_term) do |record|
+          record[:name] == project.name
+        end
+
+        QA::Runtime::Logger.debug("Found project '#{project.name}' via '#{search_term}'")
+      end
+
+      private
+
+      def find_target_in_scope(scope, search_term)
+        QA::Support::Retrier.retry_until(max_attempts: 10, sleep_interval: 10, raise_on_failure: true, retry_on_exception: true) do
+          result = search(scope, search_term)
+          result && result.any? { |record| yield record }
+        end
+      end
+
+      def search(scope, term)
+        response = get_response(scope, term)
+
+        unless response.code == singleton_class::HTTP_STATUS_OK
+          msg = "Search attempt failed. Request returned (#{response.code}): `#{response}`."
+          QA::Runtime::Logger.debug(msg)
+          raise ElasticSearchServerError, msg
+        end
+
+        parse_body(response)
+      end
+
+      def get_response(scope, term)
+        QA::Runtime::Logger.debug("Search scope '#{scope}' for '#{term}'...")
+        request = Runtime::API::Request.new(api_client, "/search?scope=#{scope}&search=#{term}")
+        get(request.url)
+      end
+
+      def verify_search_engine_ok(search_term)
+        response = get_response('commits', search_term)
+        if response.code.to_s =~ /5[0-9][0-9]/
+          raise ElasticSearchServerError, "elasticsearch attempt returned code #{response.code}. Check that search was conducted on the appropriate url and port."
+        end
+      end
+
+      def api_client
+        @api_client ||= Runtime::API::Client.new(:gitlab)
+      end
+    end
+  end
+end

data/qa/runtime/user.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module QA
+  module Runtime
+    module User
+      extend self
+
+      def admin
+        Struct.new(:username, :password).new(admin_username, admin_password)
+      end
+
+      def default_username
+        'root'
+      end
+
+      def default_email
+        'admin@example.com'
+      end
+
+      def default_password
+        '5iveL!fe'
+      end
+
+      def username
+        Runtime::Env.user_username || default_username
+      end
+
+      def password
+        Runtime::Env.user_password || default_password
+      end
+
+      def email
+        default_email
+      end
+
+      def ldap_user?
+        Runtime::Env.ldap_username && Runtime::Env.ldap_password
+      end
+
+      def ldap_username
+        Runtime::Env.ldap_username || username
+      end
+
+      def ldap_password
+        Runtime::Env.ldap_password || password
+      end
+
+      def admin_username
+        Runtime::Env.admin_username || default_username
+      end
+
+      def admin_password
+        Runtime::Env.admin_password || default_password
+      end
+    end
+  end
+end

data/qa/scenario/actable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    module Actable
+      def act(*args, &block)
+        instance_exec(*args, &block)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def perform
+          yield new if block_given?
+        end
+
+        def act(*args, &block)
+          new.act(*args, &block)
+        end
+      end
+    end
+  end
+end

data/qa/scenario/bootable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module QA
+  module Scenario
+    module Bootable
+      Option = Struct.new(:name, :arg, :desc)
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def launch!(argv)
+          return self.perform(*argv) unless has_attributes?
+
+          arguments = OptionParser.new do |parser|
+            options.to_a.each do |opt|
+              parser.on(opt.arg, opt.desc) do |value|
+                Runtime::Scenario.define(opt.name, value)
+              end
+            end
+          end
+
+          arguments.parse!(argv)
+
+          self.perform(Runtime::Scenario.attributes, *argv)
+        end
+
+        private
+
+        def attribute(name, arg, desc = '')
+          options.push(Option.new(name, arg, desc))
+        end
+
+        def options
+          # Scenario options/attributes are global. There's only ever one
+          # scenario at a time, but they can be inherited and we want scenarios
+          # to share the attributes of their ancestors. For example, `Mattermost`
+          # inherits from `Test::Instance::All` but if this were an instance
+          # variable then `Mattermost` wouldn't have access to the attributes
+          # in `All`
+          @@options ||= [] # rubocop:disable Style/ClassVars
+        end
+
+        def has_attributes?
+          options.any?
+        end
+      end
+    end
+  end
+end

data/qa/scenario/shared_attributes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    module SharedAttributes
+      include Bootable
+
+      attribute :gitlab_address, '--address URL', 'Address of the instance to test'
+      attribute :enable_feature, '--enable-feature FEATURE_FLAG', 'Enable a feature before running tests'
+      attribute :parallel, '--parallel', 'Execute tests in parallel'
+      attribute :loop, '--loop', 'Execute test repeatedly'
+    end
+  end
+end

data/qa/scenario/template.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    class Template
+      class << self
+        def perform(*args)
+          new.tap do |scenario|
+            yield scenario if block_given?
+            break scenario.perform(*args)
+          end
+        end
+
+        def tags(*tags)
+          @tags = tags
+        end
+
+        def focus
+          @tags.to_a
+        end
+      end
+
+      def perform(options, *args)
+        extract_address(:gitlab_address, options, args)
+
+        ##
+        # Perform before hooks, which are different for CE and EE
+        #
+        Runtime::Release.perform_before_hooks
+
+        Runtime::Feature.enable(options[:enable_feature]) if options.key?(:enable_feature)
+
+        Specs::Runner.perform do |specs|
+          specs.tty = true
+          specs.tags = self.class.focus
+          specs.options = args if args.any?
+        end
+      ensure
+        Runtime::Feature.disable(options[:enable_feature]) if options.key?(:enable_feature)
+      end
+
+      def extract_option(name, options, args)
+        option = if options.key?(name)
+                   options[name]
+                 else
+                   args.shift
+                 end
+
+        Runtime::Scenario.define(name, option)
+
+        option
+      end
+
+      # For backwards-compatibility, if the gitlab instance address is not
+      # specified as an option parsed by OptionParser, it can be specified as
+      # the first argument
+      def extract_address(name, options, args)
+        address = extract_option(name, options, args)
+
+        raise ::ArgumentError, "The address provided for `#{name}` is not valid: #{address}" unless Runtime::Address.valid?(address)
+      end
+    end
+  end
+end

data/qa/scenario/test/instance.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    module Test
+      # This class exists for back-compatibility so that gitlab-qa can continue
+      # to call Test::Instance instead of Test::Instance::All until at least
+      # the current latest GitLab version has the Test::Instance::All class.
+      # As of Aug, 22nd 2018. Only GitLab >= 11.3 has this class.
+      module Instance
+        include Bootable
+
+        def self.perform(*args)
+          self.tap do |scenario|
+            yield scenario if block_given?
+            break scenario.do_perform(*args)
+          end
+        end
+
+        def self.do_perform(address, *rspec_options)
+          Runtime::Scenario.define(:gitlab_address, address)
+
+          ##
+          # Perform before hooks, which are different for CE and EE
+          #
+          Runtime::Release.perform_before_hooks
+
+          Specs::Runner.perform do |specs|
+            specs.tty = true
+            specs.options = rspec_options if rspec_options.any?
+          end
+        end
+      end
+    end
+  end
+end

data/qa/scenario/test/instance/all.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    module Test
+      ##
+      # Base class for running the suite against any GitLab instance,
+      # including staging and on-premises installation.
+      #
+      module Instance
+        class All < Template
+          include Bootable
+          include SharedAttributes
+        end
+      end
+    end
+  end
+end

data/qa/scenario/test/instance/smoke.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    module Test
+      module Instance
+        ##
+        # Base class for running the suite against any GitLab instance,
+        # including staging and on-premises installation.
+        #
+        class Smoke < Template
+          include Bootable
+          include SharedAttributes
+
+          tags :smoke
+        end
+      end
+    end
+  end
+end

data/qa/scenario/test/integration/github.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    module Test
+      module Integration
+        class Github < Test::Instance::All
+          tags :github
+
+          def perform(address, *rspec_options)
+            # This test suite requires a GitHub personal access token
+            Runtime::Env.require_github_access_token!
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/qa/scenario/test/integration/instance_saml.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module QA
+  module Scenario
+    module Test
+      module Integration
+        class InstanceSAML < Test::Instance::All
+          tags :instance_saml
+        end
+      end
+    end
+  end
+end