chemlab 0.0.1

data/qa/runtime/feature.rb

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+# 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/logger.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'forwardable'
+
+module QA
+  module Runtime
+    module Logger
+      extend SingleForwardable
+
+      def_delegators :logger, :debug, :info, :warn, :error, :fatal, :unknown
+
+      singleton_class.module_eval do
+        attr_writer :logger
+
+        def logger
+          @logger ||= ::Logger.new(Runtime::Env.log_destination).tap do |logger|
+            logger.level = Runtime::Env.debug? ? ::Logger::DEBUG : ::Logger::ERROR
+          end
+        end
+      end
+    end
+  end
+end

data/qa/runtime/mail_hog.rb

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

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

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

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

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