chemlab 0.0.1 → 0.1.0

data/qa/specs/features/sanity/framework_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  context 'Framework sanity checks', :orchestrated, :framework do
-    describe 'Passing orchestrated example' do
-      it 'succeeds' do
-        Runtime::Browser.visit(:gitlab, Page::Main::Login)
-
-        expect(page).to have_text('A complete DevOps platform')
-      end
-    end
-
-    describe 'Failing orchestrated example' do
-      it 'fails' do
-        Runtime::Browser.visit(:gitlab, Page::Main::Login)
-
-        expect(page).to have_text("These Aren't the Texts You're Looking For", wait: 1)
-      end
-    end
-  end
-end

data/qa/specs/helpers/quarantine.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec/core'
-
-module QA::Specs::Helpers
-  module Quarantine
-    include RSpec::Core::Pending
-
-    extend self
-
-    def configure_rspec
-      RSpec.configure do |config|
-        config.before(:context, :quarantine) do
-          Quarantine.skip_or_run_quarantined_contexts(config.inclusion_filter.rules, self.class)
-        end
-
-        config.before do |example|
-          Quarantine.skip_or_run_quarantined_tests_or_contexts(config.inclusion_filter.rules, example)
-        end
-      end
-    end
-
-    # Skip the entire context if a context is quarantined. This avoids running
-    # before blocks unnecessarily.
-    def skip_or_run_quarantined_contexts(filters, example)
-      return unless example.metadata.key?(:quarantine)
-
-      skip_or_run_quarantined_tests_or_contexts(filters, example)
-    end
-
-    # Skip tests in quarantine unless we explicitly focus on them.
-    def skip_or_run_quarantined_tests_or_contexts(filters, example)
-      if filters.key?(:quarantine)
-        included_filters = filters_other_than_quarantine(filters)
-
-        # If :quarantine is focused, skip the test/context unless its metadata
-        # includes quarantine and any other filters
-        # E.g., Suppose a test is tagged :smoke and :quarantine, and another is tagged
-        # :ldap and :quarantine. If we wanted to run just quarantined smoke tests
-        # using `--tag quarantine --tag smoke`, without this check we'd end up
-        # running that ldap test as well because of the :quarantine metadata.
-        # We could use an exclusion filter, but this way the test report will list
-        # the quarantined tests when they're not run so that we're aware of them
-        skip("Only running tests tagged with :quarantine and any of #{included_filters.keys}") if should_skip_when_focused?(example.metadata, included_filters)
-      else
-        if example.metadata.key?(:quarantine)
-          quarantine_message = %w(In quarantine)
-          quarantine_tag = example.metadata[:quarantine]
-
-          if !!quarantine_tag
-            quarantine_message << case quarantine_tag
-                                  when String
-                                    ": #{quarantine_tag}"
-                                  when Hash
-                                    ": #{quarantine_tag[:issue]}"
-                                  else
-                                    ''
-                                  end
-          end
-
-          skip(quarantine_message.join(' ').strip)
-        end
-      end
-    end
-
-    def filters_other_than_quarantine(filter)
-      filter.reject { |key, _| key == :quarantine }
-    end
-
-    # Checks if a test or context should be skipped.
-    #
-    # Returns true if
-    # - the metadata does not includes the :quarantine tag
-    # or if
-    # - the metadata includes the :quarantine tag
-    # - and the filter includes other tags that aren't in the metadata
-    def should_skip_when_focused?(metadata, included_filters)
-      return true unless metadata.key?(:quarantine)
-      return false if included_filters.empty?
-
-      (metadata.keys & included_filters.keys).empty?
-    end
-  end
-end

data/qa/specs/loop_runner.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Specs
-    module LoopRunner
-      module_function
-
-      def run(args)
-        start = Time.now
-        loop_duration = 60 * QA::Runtime::Env.gitlab_qa_loop_runner_minutes
-
-        while Time.now - start < loop_duration
-          RSpec::Core::Runner.run(args.flatten, $stderr, $stdout).tap do |status|
-            abort if status.nonzero?
-          end
-          RSpec.clear_examples
-        end
-      end
-    end
-  end
-end

data/qa/specs/parallel_runner.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'open3'
-
-module QA
-  module Specs
-    module ParallelRunner
-      module_function
-
-      def run(args)
-        unless args.include?('--')
-          index = args.index { |opt| opt.include?('features') }
-
-          args.insert(index, '--') if index
-        end
-
-        env = {}
-        Runtime::Env::ENV_VARIABLES.each_key do |key|
-          env[key] = ENV[key] if ENV[key]
-        end
-        env['QA_RUNTIME_SCENARIO_ATTRIBUTES'] = Runtime::Scenario.attributes.to_json
-        env['GITLAB_QA_ACCESS_TOKEN'] = Runtime::API::Client.new(:gitlab).personal_access_token unless env['GITLAB_QA_ACCESS_TOKEN']
-
-        cmd = "bundle exec parallel_test -t rspec --combine-stderr --serialize-stdout -- #{args.flatten.join(' ')}"
-        ::Open3.popen2e(env, cmd) do |_, out, wait|
-          out.each { |line| puts line }
-
-          exit wait.value.exitstatus
-        end
-      end
-    end
-  end
-end

data/qa/specs/runner.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require 'knapsack'
-require 'rspec/core'
-require 'rspec/expectations'
-
-module QA
-  module Specs
-    class Runner < Scenario::Template
-      attr_accessor :tty, :tags, :options
-
-      DEFAULT_TEST_PATH_ARGS = ['--', File.expand_path('./features', __dir__)].freeze
-
-      def initialize
-        @tty = false
-        @tags = []
-        @options = []
-      end
-
-      def paths_from_knapsack
-        allocator = Knapsack::AllocatorBuilder.new(Knapsack::Adapters::RSpecAdapter).allocator
-
-        QA::Runtime::Logger.info ''
-        QA::Runtime::Logger.info 'Report specs:'
-        QA::Runtime::Logger.info allocator.report_node_tests.join(', ')
-        QA::Runtime::Logger.info ''
-        QA::Runtime::Logger.info 'Leftover specs:'
-        QA::Runtime::Logger.info allocator.leftover_node_tests.join(', ')
-        QA::Runtime::Logger.info ''
-
-        ['--', allocator.node_tests]
-      end
-
-      def rspec_tags
-        tags_for_rspec = []
-
-        if tags.any?
-          tags.each { |tag| tags_for_rspec.push(['--tag', tag.to_s]) }
-        else
-          tags_for_rspec.push(%w[--tag ~orchestrated]) unless (%w[-t --tag] & options).any?
-        end
-
-        tags_for_rspec.push(%w[--tag ~skip_signup_disabled]) if QA::Runtime::Env.signup_disabled?
-
-        tags_for_rspec.push(%w[--tag ~skip_live_env]) if QA::Runtime::Env.dot_com?
-
-        QA::Runtime::Env.supported_features.each_key do |key|
-          tags_for_rspec.push(%W[--tag ~requires_#{key}]) unless QA::Runtime::Env.can_test? key
-        end
-
-        tags_for_rspec
-      end
-
-      def perform
-        args = []
-        args.push('--tty') if tty
-        args.push(rspec_tags)
-        args.push(options)
-
-        if Runtime::Env.knapsack?
-          args.push(paths_from_knapsack)
-        else
-          args.push(DEFAULT_TEST_PATH_ARGS) unless options.any? { |opt| opt =~ %r{/features/} }
-        end
-
-        if Runtime::Scenario.attributes[:parallel]
-          ParallelRunner.run(args.flatten)
-        elsif Runtime::Scenario.attributes[:loop]
-          LoopRunner.run(args.flatten)
-        else
-          RSpec::Core::Runner.run(args.flatten, $stderr, $stdout).tap do |status|
-            abort if status.nonzero?
-          end
-        end
-      end
-    end
-  end
-end

data/qa/support/dates.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Support
-    module Dates
-      def current_date_yyyy_mm_dd
-        current_date.strftime("%Y/%m/%d")
-      end
-
-      def next_month_yyyy_mm_dd
-        current_date.next_month.strftime("%Y/%m/%d")
-      end
-
-      private
-
-      def current_date
-        DateTime.now
-      end
-    end
-  end
-end

data/qa/support/page/logging.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Support
-    module Page
-      module Logging
-        def assert_no_element(name)
-          log("asserting no element :#{name}")
-
-          super
-        end
-
-        def refresh
-          log("refreshing #{current_url}")
-
-          super
-        end
-
-        def scroll_to(selector, text: nil)
-          msg = "scrolling to :#{selector}"
-          msg += " with text: #{text}" if text
-          log(msg)
-
-          super
-        end
-
-        def asset_exists?(url)
-          exists = super
-
-          log("asset_exists? #{url} returned #{exists}")
-
-          exists
-        end
-
-        def find_element(name, **kwargs)
-          log("finding :#{name} with args #{kwargs}")
-
-          element = super
-
-          log("found :#{name}") if element
-
-          element
-        end
-
-        def all_elements(name, **kwargs)
-          log("finding all :#{name} with args #{kwargs}")
-
-          elements = super
-
-          log("found #{elements.size} :#{name}") if elements
-
-          elements
-        end
-
-        def check_element(name)
-          log("checking :#{name}")
-
-          super
-        end
-
-        def uncheck_element(name)
-          log("unchecking :#{name}")
-
-          super
-        end
-
-        def click_element(name, page = nil, **kwargs)
-          msg = ["clicking :#{name}"]
-          msg << ", expecting to be at #{page.class}" if page
-          msg << "with args #{kwargs}"
-
-          log(msg.compact.join(' '))
-
-          super
-        end
-
-        def fill_element(name, content)
-          masked_content = name.to_s.include?('password') ? '*****' : content
-
-          log(%Q(filling :#{name} with "#{masked_content}"))
-
-          super
-        end
-
-        def select_element(name, value)
-          log(%Q(selecting "#{value}" in :#{name}))
-
-          super
-        end
-
-        def has_element?(name, **kwargs)
-          found = super
-
-          log_has_element_or_not('has_element?', name, found, **kwargs)
-
-          found
-        end
-
-        def has_no_element?(name, **kwargs)
-          found = super
-
-          log_has_element_or_not('has_no_element?', name, found, **kwargs)
-
-          found
-        end
-
-        def has_text?(text, **kwargs)
-          found = super
-
-          log(%Q{has_text?('#{text}', wait: #{kwargs[:wait] || Capybara.default_max_wait_time}) returned #{found}})
-
-          found
-        end
-
-        def has_no_text?(text, **kwargs)
-          found = super
-
-          log(%Q{has_no_text?('#{text}', wait: #{kwargs[:wait] || Capybara.default_max_wait_time}) returned #{found}})
-
-          found
-        end
-
-        def finished_loading?
-          log('waiting for loading to complete...')
-          now = Time.now
-
-          loaded = super
-
-          log("loading complete after #{Time.now - now} seconds")
-
-          loaded
-        end
-
-        def wait_for_animated_element(name)
-          log("waiting for animated element: #{name}")
-
-          super
-        end
-
-        def within_element(name, text: nil)
-          log("within element :#{name}")
-
-          element = super
-
-          log("end within element :#{name}")
-
-          element
-        end
-
-        def within_element_by_index(name, index)
-          log("within elements :#{name} at index #{index}")
-
-          element = super
-
-          log("end within elements :#{name} at index #{index}")
-
-          element
-        end
-
-        private
-
-        def log(msg)
-          QA::Runtime::Logger.debug(msg)
-        end
-
-        def log_has_element_or_not(method, name, found, **kwargs)
-          msg = ["#{method} :#{name}"]
-          msg << %Q(with text "#{kwargs[:text]}") if kwargs[:text]
-          msg << "class: #{kwargs[:class]}" if kwargs[:class]
-          msg << "(wait: #{kwargs[:wait] || Capybara.default_max_wait_time})"
-          msg << "returned: #{found}"
-
-          log(msg.compact.join(' '))
-        end
-      end
-    end
-  end
-end

data/qa/support/retrier.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Support
-    module Retrier
-      extend Repeater
-
-      module_function
-
-      def retry_on_exception(max_attempts: 3, reload_page: nil, sleep_interval: 0.5)
-        QA::Runtime::Logger.debug(
-          <<~MSG.tr("\n", ' ')
-            with retry_on_exception: max_attempts: #{max_attempts};
-            reload_page: #{reload_page};
-            sleep_interval: #{sleep_interval}
-        MSG
-        )
-
-        result = nil
-        repeat_until(
-          max_attempts: max_attempts,
-          reload_page: reload_page,
-          sleep_interval: sleep_interval,
-          retry_on_exception: true
-        ) do
-          result = yield
-
-          # This method doesn't care what the return value of the block is.
-          # We set it to `true` so that it doesn't repeat if there's no exception
-          true
-        end
-        QA::Runtime::Logger.debug("ended retry_on_exception")
-
-        result
-      end
-
-      def retry_until(max_attempts: nil, max_duration: nil, reload_page: nil, sleep_interval: 0, raise_on_failure: true, retry_on_exception: false)
-        # For backwards-compatibility
-        max_attempts = 3 if max_attempts.nil? && max_duration.nil?
-
-        start_msg ||= ["with retry_until:"]
-        start_msg << "max_attempts: #{max_attempts};" if max_attempts
-        start_msg << "max_duration: #{max_duration};" if max_duration
-        start_msg << "reload_page: #{reload_page}; sleep_interval: #{sleep_interval}; raise_on_failure: #{raise_on_failure}; retry_on_exception: #{retry_on_exception}"
-        QA::Runtime::Logger.debug(start_msg.join(' '))
-
-        result = nil
-        repeat_until(
-          max_attempts: max_attempts,
-          max_duration: max_duration,
-          reload_page: reload_page,
-          sleep_interval: sleep_interval,
-          raise_on_failure: raise_on_failure,
-          retry_on_exception: retry_on_exception
-        ) do
-          result = yield
-        end
-        QA::Runtime::Logger.debug("ended retry_until")
-
-        result
-      end
-    end
-  end
-end