chemlab 0.0.1

data/qa/runtime/browser.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'rspec/core'
+require 'rspec/expectations'
+require 'capybara/rspec'
+require 'capybara-screenshot/rspec'
+require 'selenium-webdriver'
+
+module QA
+  module Runtime
+    class Browser
+      include QA::Scenario::Actable
+
+      NotRespondingError = Class.new(RuntimeError)
+
+      CAPYBARA_MAX_WAIT_TIME = 10
+
+      def initialize
+        self.class.configure!
+      end
+
+      def self.blank_page?
+        ['', 'about:blank', 'data:,'].include?(Capybara.current_session.driver.browser.current_url)
+      rescue
+        true
+      end
+
+      ##
+      # Visit a page that belongs to a GitLab instance under given address.
+      #
+      # Example:
+      #
+      # visit(:gitlab, Page::Main::Login)
+      # visit('http://gitlab.example/users/sign_in')
+      #
+      # In case of an address that is a symbol we will try to guess address
+      # based on `Runtime::Scenario#something_address`.
+      #
+      def visit(address, page_class, &block)
+        Browser::Session.new(address, page_class).perform(&block)
+      end
+
+      def self.visit(address, page_class, &block)
+        new.visit(address, page_class, &block)
+      end
+
+      # rubocop: disable Metrics/AbcSize
+      def self.configure!
+        RSpec.configure do |config|
+          config.define_derived_metadata(file_path: %r{/qa/specs/features/}) do |metadata|
+            metadata[:type] = :feature
+          end
+
+          config.append_after(:each) do |example|
+            if example.metadata[:screenshot]
+              screenshot = example.metadata[:screenshot][:image] || example.metadata[:screenshot][:html]
+              example.metadata[:stdout] = %{[[ATTACHMENT|#{screenshot}]]}
+            end
+          end
+        end
+
+        Capybara.server_port = 9887 + ENV['TEST_ENV_NUMBER'].to_i
+
+        return if Capybara.drivers.include?(:chrome)
+
+        Capybara.register_driver QA::Runtime::Env.browser do |app|
+          capabilities = Selenium::WebDriver::Remote::Capabilities.send(QA::Runtime::Env.browser,
+            # This enables access to logs with `page.driver.manage.get_log(:browser)`
+            loggingPrefs: {
+              browser: "ALL",
+              client: "ALL",
+              driver: "ALL",
+              server: "ALL"
+            })
+
+          if QA::Runtime::Env.accept_insecure_certs?
+            capabilities['acceptInsecureCerts'] = true
+          end
+
+          # QA::Runtime::Env.browser.capitalize will work for every driver type except PhantomJS.
+          # We will have no use to use PhantomJS so this shouldn't be a problem.
+          options = Selenium::WebDriver.const_get(QA::Runtime::Env.browser.capitalize, false)::Options.new
+
+          if QA::Runtime::Env.browser == :chrome
+            options.add_argument("window-size=1480,2200")
+
+            # Chrome won't work properly in a Docker container in sandbox mode
+            options.add_argument("no-sandbox")
+
+            # Run headless by default unless CHROME_HEADLESS is false
+            if QA::Runtime::Env.chrome_headless?
+              options.add_argument("headless")
+
+              # Chrome documentation says this flag is needed for now
+              # https://developers.google.com/web/updates/2017/04/headless-chrome#cli
+              options.add_argument("disable-gpu")
+            end
+
+            # Disable /dev/shm use in CI. See https://gitlab.com/gitlab-org/gitlab/issues/4252
+            options.add_argument("disable-dev-shm-usage") if QA::Runtime::Env.running_in_ci?
+          end
+
+          # Use the same profile on QA runs if CHROME_REUSE_PROFILE is true.
+          # Useful to speed up local QA.
+          if QA::Runtime::Env.reuse_chrome_profile?
+            qa_profile_dir = ::File.expand_path('../../tmp/qa-profile', __dir__)
+            options.add_argument("user-data-dir=#{qa_profile_dir}")
+          end
+
+          selenium_options = {
+            browser: QA::Runtime::Env.browser,
+            clear_local_storage: true,
+            desired_capabilities: capabilities,
+            options: options
+          }
+
+          selenium_options[:url] = QA::Runtime::Env.remote_grid if QA::Runtime::Env.remote_grid
+
+          Capybara::Selenium::Driver.new(
+            app,
+            selenium_options
+          )
+        end
+
+        # Keep only the screenshots generated from the last failing test suite
+        Capybara::Screenshot.prune_strategy = :keep_last_run
+
+        # From https://github.com/mattheworiordan/capybara-screenshot/issues/84#issuecomment-41219326
+        Capybara::Screenshot.register_driver(QA::Runtime::Env.browser) do |driver, path|
+          driver.browser.save_screenshot(path)
+        end
+
+        Capybara::Screenshot.append_timestamp = false
+
+        Capybara::Screenshot.register_filename_prefix_formatter(:rspec) do |example|
+          ::File.join(QA::Runtime::Namespace.name, example.full_description.downcase.parameterize(separator: "_")[0..99])
+        end
+
+        Capybara.configure do |config|
+          config.default_driver = QA::Runtime::Env.browser
+          config.javascript_driver = QA::Runtime::Env.browser
+          config.default_max_wait_time = CAPYBARA_MAX_WAIT_TIME
+          # https://github.com/mattheworiordan/capybara-screenshot/issues/164
+          config.save_path = ::File.expand_path('../../tmp', __dir__)
+
+          # Cabybara 3 does not normalize text by default, so older tests
+          # fail because of unexpected line breaks and other white space
+          config.default_normalize_ws = true
+        end
+      end
+      # rubocop: enable Metrics/AbcSize
+
+      class Session
+        include Capybara::DSL
+
+        attr_reader :page_class
+
+        def initialize(instance, page_class)
+          @session_address = Runtime::Address.new(instance, page_class)
+          @page_class = page_class
+        end
+
+        def url
+          @session_address.address
+        end
+
+        def perform(&block)
+          visit(url)
+
+          simulate_slow_connection if Runtime::Env.simulate_slow_connection?
+
+          page_class.validate_elements_present!
+
+          if QA::Runtime::Env.qa_cookies
+            browser = Capybara.current_session.driver.browser
+            QA::Runtime::Env.qa_cookies.each do |cookie|
+              name, value = cookie.split("=")
+              value ||= ""
+              browser.manage.add_cookie name: name, value: value
+            end
+          end
+
+          yield.tap { clear! } if block_given?
+        end
+
+        ##
+        # Selenium allows to reset session cookies for current domain only.
+        #
+        # See gitlab-org/gitlab-qa#102
+        #
+        def clear!
+          visit(url)
+          reset_session!
+          @network_conditions_configured = false
+        end
+
+        private
+
+        def simulate_slow_connection
+          return if @network_conditions_configured
+
+          QA::Runtime::Logger.info(
+            <<~MSG.tr("\n", " ")
+              Simulating a slow connection with additional latency
+              of #{Runtime::Env.slow_connection_latency} ms and a maximum
+              throughput of #{Runtime::Env.slow_connection_throughput} kbps
+            MSG
+          )
+
+          Capybara.current_session.driver.browser.network_conditions = {
+            latency: Runtime::Env.slow_connection_latency,
+            throughput: Runtime::Env.slow_connection_throughput * 1000
+          }
+
+          @network_conditions_configured = true
+        end
+      end
+    end
+  end
+end

data/qa/runtime/env.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require 'gitlab/qa'
+
+module QA
+  module Runtime
+    module Env
+      extend self
+
+      attr_writer :personal_access_token, :ldap_username, :ldap_password
+
+      ENV_VARIABLES = Gitlab::QA::Runtime::Env::ENV_VARIABLES
+
+      # The environment variables used to indicate if the environment under test
+      # supports the given feature
+      SUPPORTED_FEATURES = {
+        git_protocol_v2: 'QA_CAN_TEST_GIT_PROTOCOL_V2',
+        admin: 'QA_CAN_TEST_ADMIN_FEATURES',
+        praefect: 'QA_CAN_TEST_PRAEFECT'
+      }.freeze
+
+      def supported_features
+        SUPPORTED_FEATURES
+      end
+
+      def dot_com?
+        Runtime::Scenario.gitlab_address.include?(".com")
+      end
+
+      def additional_repository_storage
+        ENV['QA_ADDITIONAL_REPOSITORY_STORAGE']
+      end
+
+      def praefect_repository_storage
+        ENV['QA_PRAEFECT_REPOSITORY_STORAGE']
+      end
+
+      def admin_password
+        ENV['GITLAB_ADMIN_PASSWORD']
+      end
+
+      def admin_username
+        ENV['GITLAB_ADMIN_USERNAME']
+      end
+
+      def admin_personal_access_token
+        ENV['GITLAB_QA_ADMIN_ACCESS_TOKEN']
+      end
+
+      def ci_project_name
+        ENV['CI_PROJECT_NAME']
+      end
+
+      def debug?
+        enabled?(ENV['QA_DEBUG'], default: false)
+      end
+
+      def log_destination
+        ENV['QA_LOG_PATH'] || $stdout
+      end
+
+      # set to 'false' to have Chrome run visibly instead of headless
+      def chrome_headless?
+        enabled?(ENV['CHROME_HEADLESS'])
+      end
+
+      # set to 'true' to have Chrome use a fixed profile directory
+      def reuse_chrome_profile?
+        enabled?(ENV['CHROME_REUSE_PROFILE'], default: false)
+      end
+
+      def accept_insecure_certs?
+        enabled?(ENV['ACCEPT_INSECURE_CERTS'])
+      end
+
+      def running_in_ci?
+        ENV['CI'] || ENV['CI_SERVER']
+      end
+
+      def qa_cookies
+        ENV['QA_COOKIES'] && ENV['QA_COOKIES'].split(';')
+      end
+
+      def signup_disabled?
+        enabled?(ENV['SIGNUP_DISABLED'], default: false)
+      end
+
+      # specifies token that can be used for the api
+      def personal_access_token
+        @personal_access_token ||= ENV['GITLAB_QA_ACCESS_TOKEN']
+      end
+
+      def remote_grid
+        # if username specified, password/auth token is required
+        # can be
+        # - "http://user:pass@somehost.com/wd/hub"
+        # - "https://user:pass@somehost.com:443/wd/hub"
+        # - "http://localhost:4444/wd/hub"
+
+        return if (ENV['QA_REMOTE_GRID'] || '').empty?
+
+        "#{remote_grid_protocol}://#{remote_grid_credentials}#{ENV['QA_REMOTE_GRID']}/wd/hub"
+      end
+
+      def remote_grid_username
+        ENV['QA_REMOTE_GRID_USERNAME']
+      end
+
+      def remote_grid_access_key
+        ENV['QA_REMOTE_GRID_ACCESS_KEY']
+      end
+
+      def remote_grid_protocol
+        ENV['QA_REMOTE_GRID_PROTOCOL'] || 'http'
+      end
+
+      def browser
+        ENV['QA_BROWSER'].nil? ? :chrome : ENV['QA_BROWSER'].to_sym
+      end
+
+      def user_username
+        ENV['GITLAB_USERNAME']
+      end
+
+      def user_password
+        ENV['GITLAB_PASSWORD']
+      end
+
+      def github_username
+        ENV['GITHUB_USERNAME']
+      end
+
+      def github_password
+        ENV['GITHUB_PASSWORD']
+      end
+
+      def forker?
+        !!(forker_username && forker_password)
+      end
+
+      def forker_username
+        ENV['GITLAB_FORKER_USERNAME']
+      end
+
+      def forker_password
+        ENV['GITLAB_FORKER_PASSWORD']
+      end
+
+      def gitlab_qa_username_1
+        ENV['GITLAB_QA_USERNAME_1'] || 'gitlab-qa-user1'
+      end
+
+      def gitlab_qa_password_1
+        ENV['GITLAB_QA_PASSWORD_1']
+      end
+
+      def gitlab_qa_username_2
+        ENV['GITLAB_QA_USERNAME_2'] || 'gitlab-qa-user2'
+      end
+
+      def gitlab_qa_password_2
+        ENV['GITLAB_QA_PASSWORD_2']
+      end
+
+      def gitlab_qa_username_3
+        ENV['GITLAB_QA_USERNAME_3'] || 'gitlab-qa-user3'
+      end
+
+      def gitlab_qa_password_3
+        ENV['GITLAB_QA_PASSWORD_3']
+      end
+
+      def gitlab_qa_username_4
+        ENV['GITLAB_QA_USERNAME_4'] || 'gitlab-qa-user4'
+      end
+
+      def gitlab_qa_password_4
+        ENV['GITLAB_QA_PASSWORD_4']
+      end
+
+      def gitlab_qa_username_5
+        ENV['GITLAB_QA_USERNAME_5'] || 'gitlab-qa-user5'
+      end
+
+      def gitlab_qa_password_5
+        ENV['GITLAB_QA_PASSWORD_5']
+      end
+
+      def gitlab_qa_username_6
+        ENV['GITLAB_QA_USERNAME_6'] || 'gitlab-qa-user6'
+      end
+
+      def gitlab_qa_password_6
+        ENV['GITLAB_QA_PASSWORD_6']
+      end
+
+      def gitlab_qa_1p_email
+        ENV['GITLAB_QA_1P_EMAIL']
+      end
+
+      def gitlab_qa_1p_password
+        ENV['GITLAB_QA_1P_PASSWORD']
+      end
+
+      def gitlab_qa_1p_secret
+        ENV['GITLAB_QA_1P_SECRET']
+      end
+
+      def gitlab_qa_1p_github_uuid
+        ENV['GITLAB_QA_1P_GITHUB_UUID']
+      end
+
+      def knapsack?
+        !!(ENV['KNAPSACK_GENERATE_REPORT'] || ENV['KNAPSACK_REPORT_PATH'] || ENV['KNAPSACK_TEST_FILE_PATTERN'])
+      end
+
+      def ldap_username
+        @ldap_username ||= ENV['GITLAB_LDAP_USERNAME']
+      end
+
+      def ldap_password
+        @ldap_password ||= ENV['GITLAB_LDAP_PASSWORD']
+      end
+
+      def sandbox_name
+        ENV['GITLAB_SANDBOX_NAME']
+      end
+
+      def namespace_name
+        ENV['GITLAB_NAMESPACE_NAME']
+      end
+
+      def auto_devops_project_name
+        ENV['GITLAB_AUTO_DEVOPS_PROJECT_NAME']
+      end
+
+      def gcloud_account_key
+        ENV.fetch("GCLOUD_ACCOUNT_KEY")
+      end
+
+      def gcloud_account_email
+        ENV.fetch("GCLOUD_ACCOUNT_EMAIL")
+      end
+
+      def gcloud_region
+        ENV['GCLOUD_REGION']
+      end
+
+      def gcloud_num_nodes
+        ENV.fetch('GCLOUD_NUM_NODES', 1)
+      end
+
+      def has_gcloud_credentials?
+        %w[GCLOUD_ACCOUNT_KEY GCLOUD_ACCOUNT_EMAIL].none? { |var| ENV[var].to_s.empty? }
+      end
+
+      # Specifies the token that can be used for the GitHub API
+      def github_access_token
+        ENV['GITHUB_ACCESS_TOKEN'].to_s.strip
+      end
+
+      def require_github_access_token!
+        return unless github_access_token.empty?
+
+        raise ArgumentError, "Please provide GITHUB_ACCESS_TOKEN"
+      end
+
+      def require_admin_access_token!
+        admin_personal_access_token || (raise ArgumentError, "GITLAB_QA_ADMIN_ACCESS_TOKEN is required!")
+      end
+
+      # Returns true if there is an environment variable that indicates that
+      # the feature is supported in the environment under test.
+      # All features are supported by default.
+      def can_test?(feature)
+        raise ArgumentError, %Q(Unknown feature "#{feature}") unless SUPPORTED_FEATURES.include? feature
+
+        enabled?(ENV[SUPPORTED_FEATURES[feature]], default: true)
+      end
+
+      def runtime_scenario_attributes
+        ENV['QA_RUNTIME_SCENARIO_ATTRIBUTES']
+      end
+
+      def disable_rspec_retry?
+        enabled?(ENV['QA_DISABLE_RSPEC_RETRY'], default: false)
+      end
+
+      def simulate_slow_connection?
+        enabled?(ENV['QA_SIMULATE_SLOW_CONNECTION'], default: false)
+      end
+
+      def slow_connection_latency
+        ENV.fetch('QA_SLOW_CONNECTION_LATENCY_MS', 2000).to_i
+      end
+
+      def slow_connection_throughput
+        ENV.fetch('QA_SLOW_CONNECTION_THROUGHPUT_KBPS', 32).to_i
+      end
+
+      def gitlab_qa_loop_runner_minutes
+        ENV.fetch('GITLAB_QA_LOOP_RUNNER_MINUTES', 1).to_i
+      end
+
+      def mailhog_hostname
+        ENV['MAILHOG_HOSTNAME']
+      end
+
+      private
+
+      def remote_grid_credentials
+        if remote_grid_username
+          raise ArgumentError, %Q(Please provide an access key for user "#{remote_grid_username}") unless remote_grid_access_key
+
+          return "#{remote_grid_username}:#{remote_grid_access_key}@"
+        end
+
+        ''
+      end
+
+      def enabled?(value, default: true)
+        return default if value.nil?
+
+        (value =~ /^(false|no|0)$/i) != 0
+      end
+    end
+  end
+end
+
+QA::Runtime::Env.extend_if_ee('QA::EE::Runtime::Env')