chemlab 0.0.1 → 0.1.0

data/qa/runtime/feature.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module Feature
-      extend self
-      extend Support::Api
-
-      SetFeatureError = Class.new(RuntimeError)
-      AuthorizationError = Class.new(RuntimeError)
-
-      def enable(key)
-        QA::Runtime::Logger.info("Enabling feature: #{key}")
-        set_feature(key, true)
-      end
-
-      def disable(key)
-        QA::Runtime::Logger.info("Disabling feature: #{key}")
-        set_feature(key, false)
-      end
-
-      def remove(key)
-        request = Runtime::API::Request.new(api_client, "/features/#{key}")
-        response = delete(request.url)
-        unless response.code == QA::Support::Api::HTTP_STATUS_NO_CONTENT
-          raise SetFeatureError, "Deleting feature flag #{key} failed with `#{response}`."
-        end
-      end
-
-      def enable_and_verify(key)
-        Support::Retrier.retry_on_exception(sleep_interval: 2) do
-          enable(key)
-
-          is_enabled = false
-
-          QA::Support::Waiter.wait_until(sleep_interval: 1) do
-            is_enabled = enabled?(key)
-          end
-
-          raise SetFeatureError, "#{key} was not enabled!" unless is_enabled
-
-          QA::Runtime::Logger.info("Successfully enabled and verified feature flag: #{key}")
-        end
-      end
-
-      def enabled?(key)
-        feature = JSON.parse(get_features).find { |flag| flag["name"] == key }
-        feature && feature["state"] == "on"
-      end
-
-      def get_features
-        request = Runtime::API::Request.new(api_client, "/features")
-        response = get(request.url)
-        response.body
-      end
-
-      private
-
-      def api_client
-        @api_client ||= begin
-          if Runtime::Env.admin_personal_access_token
-            Runtime::API::Client.new(:gitlab, personal_access_token: Runtime::Env.admin_personal_access_token)
-          else
-            user = Resource::User.fabricate_via_api! do |user|
-              user.username = Runtime::User.admin_username
-              user.password = Runtime::User.admin_password
-            end
-
-            unless user.admin?
-              raise AuthorizationError, "Administrator access is required to enable/disable feature flags. User '#{user.username}' is not an administrator."
-            end
-
-            Runtime::API::Client.new(:gitlab, user: user)
-          end
-        end
-      end
-
-      def set_feature(key, value)
-        request = Runtime::API::Request.new(api_client, "/features/#{key}")
-        response = post(request.url, { value: value })
-        unless response.code == QA::Support::Api::HTTP_STATUS_CREATED
-          raise SetFeatureError, "Setting feature flag #{key} to #{value} failed with `#{response}`."
-        end
-      end
-    end
-  end
-end

data/qa/runtime/fixtures.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'tmpdir'
-
-module QA
-  module Runtime
-    module Fixtures
-      include Support::Api
-
-      TemplateNotFoundError = Class.new(RuntimeError)
-
-      def fetch_template_from_api(api_path, key)
-        request = Runtime::API::Request.new(api_client, "/templates/#{api_path}/#{key}")
-        response = get(request.url)
-
-        unless response.code == HTTP_STATUS_OK
-          raise TemplateNotFoundError, "Template at #{request.mask_url} could not be found (#{response.code}): `#{response}`."
-        end
-
-        parse_body(response)[:content]
-      end
-
-      def with_fixtures(fixtures)
-        dir = Dir.mktmpdir
-        fixtures.each do |file_def|
-          path = File.join(dir, file_def[:file_path])
-          FileUtils.mkdir_p(File.dirname(path))
-          File.write(path, file_def[:content])
-        end
-
-        yield dir
-      ensure
-        FileUtils.remove_entry(dir, true)
-      end
-
-      private
-
-      def api_client
-        @api_client ||= Runtime::API::Client.new(:gitlab)
-      end
-    end
-  end
-end

data/qa/runtime/gpg.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    class GPG
-      attr_reader :key, :key_id
-
-      def initialize
-        @key_id = 'B8358D73048DACC4'
-        import_key(File.expand_path('qa/ee/fixtures/gpg/admin.asc'))
-        @key = collect_key.first
-      end
-
-      private
-
-      def import_key(path)
-        import_key = "gpg --import #{path}"
-        execute(import_key)
-      end
-
-      def collect_key
-        get_ascii_format = "gpg --armor --export #{@key_id}"
-        execute(get_ascii_format)
-      end
-
-      def execute(command)
-        Open3.capture2e(*command) do |stdin, out, wait|
-          out.each_char { |char| print char }
-
-          if wait.value.exited? && wait.value.exitstatus.nonzero?
-            raise CommandError, "Command `#{command}` failed!"
-          end
-        end
-      end
-    end
-  end
-end

data/qa/runtime/ip_address.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-require 'socket'
-
-module QA
-  module Runtime
-    module IPAddress
-      include Support::Api
-      HostUnreachableError = Class.new(StandardError)
-
-      LOOPBACK_ADDRESS = '127.0.0.1'
-      PUBLIC_IP_ADDRESS_API = "https://api.ipify.org"
-
-      def fetch_current_ip_address
-        # When running on CI against a live environment such as staging.gitlab.com,
-        # we use the public facing IP address
-        ip_address = if Env.running_in_ci? && !URI.parse(Scenario.gitlab_address).host.include?('test')
-                       response = get(PUBLIC_IP_ADDRESS_API)
-                       raise HostUnreachableError, "#{PUBLIC_IP_ADDRESS_API} is unreachable" unless response.code == Support::Api::HTTP_STATUS_OK
-
-                       response.body
-                     elsif page.current_host.include?('localhost')
-                       LOOPBACK_ADDRESS
-                     else
-                       Socket.ip_address_list.detect { |intf| intf.ipv4_private? }.ip_address
-                     end
-
-        QA::Runtime::Logger.info "Current IP address: #{ip_address}"
-
-        ip_address
-      end
-    end
-  end
-end

data/qa/runtime/key/base.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module Key
-      class Base
-        attr_reader :name, :bits, :private_key, :public_key, :md5_fingerprint
-
-        def initialize(name, bits)
-          @name = name
-          @bits = bits
-
-          Dir.mktmpdir do |dir|
-            path = "#{dir}/id_#{name}"
-
-            ssh_keygen(name, bits, path)
-            populate_key_data(path)
-          end
-        end
-
-        private
-
-        def ssh_keygen(name, bits, path)
-          cmd = %W[ssh-keygen -t #{name} -b #{bits} -f #{path} -N] << ''
-
-          Service::Shellout.shell(cmd)
-        end
-
-        def populate_key_data(path)
-          @private_key = ::File.binread(path)
-          @public_key = ::File.binread("#{path}.pub")
-          @md5_fingerprint =
-            `ssh-keygen -l -E md5 -f #{path} | cut -d' ' -f2 | cut -d: -f2-`.chomp
-        end
-      end
-    end
-  end
-end

data/qa/runtime/key/ecdsa.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module Key
-      class ECDSA < Base
-        def initialize(bits = 521)
-          super('ecdsa', bits)
-        end
-      end
-    end
-  end
-end

data/qa/runtime/key/ed25519.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module Key
-      class ED25519 < Base
-        def initialize
-          super('ed25519', 256)
-        end
-      end
-    end
-  end
-end

data/qa/runtime/key/rsa.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module Key
-      class RSA < Base
-        def initialize(bits = 4096)
-          super('rsa', bits)
-        end
-      end
-    end
-  end
-end

data/qa/runtime/mail_hog.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-module QA
-  module Runtime
-    module MailHog
-      def self.base_url
-        host = QA::Runtime::Env.mailhog_hostname || 'localhost'
-        "http://#{host}:8025"
-      end
-
-      def self.api_messages_url
-        "#{base_url}/api/v2/messages"
-      end
-    end
-  end
-end

data/qa/runtime/namespace.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module Namespace
-      extend self
-
-      def time
-        @time ||= Time.now
-      end
-
-      def name
-        # If any changes are made to the name tag, following script has to be considered:
-        # https://ops.gitlab.net/gitlab-com/gl-infra/traffic-generator/blob/master/bin/janitor.bash
-        @name ||= Runtime::Env.namespace_name || "qa-test-#{time.strftime('%Y-%m-%d-%H-%M-%S')}-#{SecureRandom.hex(8)}"
-      end
-
-      def path
-        "#{sandbox_name}/#{name}"
-      end
-
-      def sandbox_name
-        Runtime::Env.sandbox_name || 'gitlab-qa-sandbox-group'
-      end
-    end
-  end
-end

data/qa/runtime/path.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Runtime
-    module Path
-      extend self
-
-      def qa_root
-        ::File.expand_path('../../', __dir__)
-      end
-    end
-  end
-end

data/qa/runtime/release.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'capybara/rspec'
-require 'capybara-screenshot/rspec'
-
-module QA
-  module Runtime
-    ##
-    # Class that is responsible for plugging CE/EE extensions in, depending on
-    # existence of EE module.
-    #
-    # We need that to reduce the probability of conflicts when merging
-    # CE to EE.
-    #
-    class Release
-      def initialize
-        require "qa/#{version.downcase}/strategy"
-      end
-
-      def version
-        @version ||= ::File.directory?("#{__dir__}/../ee") ? :EE : :CE
-      end
-
-      def strategy
-        Object.const_get("QA::#{version}::Strategy", false)
-      end
-
-      def self.method_missing(name, *args)
-        self.new.strategy.public_send(name, *args)
-      rescue
-        saved = Capybara::Screenshot.screenshot_and_save_page
-
-        QA::Runtime::Logger.error("Screenshot: #{saved[:image]}") if saved&.key?(:image)
-        QA::Runtime::Logger.error("HTML capture: #{saved[:html]}") if saved&.key?(:html)
-
-        raise
-      end
-    end
-  end
-end

data/qa/runtime/scenario.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module QA
-  module Runtime
-    ##
-    # Singleton approach to global test scenario arguments.
-    #
-    module Scenario
-      extend self
-
-      def attributes
-        @attributes ||= {}
-      end
-
-      def define(attribute, value)
-        attributes.store(attribute.to_sym, value)
-
-        define_singleton_method(attribute) do
-          attributes[attribute.to_sym].tap do |value|
-            if value.to_s.empty?
-              raise ArgumentError, "Empty `#{attribute}` attribute!"
-            end
-          end
-        end
-      end
-
-      def from_env(var)
-        JSON.parse(Runtime::Env.runtime_scenario_attributes).each { |k, v| define(k, v) }
-      end
-
-      def method_missing(name, *)
-        raise ArgumentError, "Scenario attribute `#{name}` not defined!"
-      end
-    end
-  end
-end

data/qa/runtime/search.rb

@@ -1,124 +0,0 @@
-# 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