chemlab 0.5.0 → 0.6.0

data/lib/chemlab/resource.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/array/extract_options'
-
-module Chemlab
-  class Resource
-    extend SingleForwardable
-    include ApiFabricator
-
-    NoValueError = Class.new(RuntimeError)
-
-    def_delegators :evaluator, :attribute
-
-    def initialize(api_client)
-      @api_client = api_client
-    end
-
-    def self.fabricate!(*args, &prepare_block)
-      fabricate_via_api!(*args, &prepare_block)
-    rescue NotImplementedError
-      fabricate_via_browser_ui!(*args, &prepare_block)
-    end
-
-    def self.fabricate_via_browser_ui!(*args, &prepare_block)
-      options = args.extract_options!
-      resource = options.fetch(:resource) { new }
-      parents = options.fetch(:parents) { [] }
-
-      do_fabricate!(resource: resource, prepare_block: prepare_block, parents: parents) do
-        log_fabrication(:browser_ui, resource, parents, args) { resource.fabricate!(*args) }
-
-        current_url
-      end
-    end
-
-    def self.fabricate_via_api!(*args, &prepare_block)
-      options = args.extract_options!
-      resource = options.fetch(:resource) { new }
-      parents = options.fetch(:parents) { [] }
-
-      raise NotImplementedError unless resource.api_support?
-
-      resource.eager_load_api_client!
-
-      do_fabricate!(resource: resource, prepare_block: prepare_block, parents: parents) do
-        log_fabrication(:api, resource, parents, args) { resource.fabricate_via_api! }
-      end
-    end
-
-    def self.remove_via_api!(*args, &prepare_block)
-      options = args.extract_options!
-      resource = options.fetch(:resource) { new }
-      parents = options.fetch(:parents) { [] }
-
-      resource.eager_load_api_client!
-
-      do_fabricate!(resource: resource, prepare_block: prepare_block, parents: parents) do
-        log_fabrication(:api, resource, parents, args) { resource.remove_via_api! }
-      end
-    end
-
-    def fabricate!(*_args)
-      raise NotImplementedError
-    end
-
-    def visit!
-      Runtime::Logger.debug(%Q[Visiting #{self.class.name} at "#{web_url}"])
-
-      # Just in case an async action is not yet complete
-      Support::WaitForRequests.wait_for_requests
-
-      Support::Retrier.retry_until do
-        visit(web_url)
-        wait_until { current_url.include?(URI.parse(web_url).path.split('/').last || web_url) }
-      end
-    end
-
-    def populate(*attributes)
-      attributes.each(&method(:public_send))
-    end
-
-    def wait_until(max_duration: 60, sleep_interval: 0.1)
-      Support::Waiter.wait_until(max_duration: max_duration, sleep_interval: sleep_interval) do
-        yield
-      end
-    end
-
-    private
-
-    def populate_attribute(name, block)
-      value = attribute_value(name, block)
-
-      raise NoValueError, "No value was computed for #{name} of #{self.class.name}." unless value
-
-      value
-    end
-
-    def attribute_value(name, block)
-      api_value = api_resource&.dig(name)
-
-      if api_value && block
-        log_having_both_api_result_and_block(name, api_value)
-      end
-
-      api_value || (block && instance_exec(&block))
-    end
-
-    def log_having_both_api_result_and_block(name, api_value)
-      QA::Runtime::Logger.info "<#{self.class}> Attribute #{name.inspect} has both API response `#{api_value}` and a block. API response will be picked. Block will be ignored."
-    end
-
-    def self.do_fabricate!(resource:, prepare_block:, parents: [])
-      prepare_block.call(resource) if prepare_block
-
-      resource_web_url = yield
-      resource.web_url = resource_web_url
-
-      resource
-    end
-
-    private_class_method :do_fabricate!
-
-    def self.log_fabrication(method, resource, parents, args)
-      return yield unless Runtime::Env.debug?
-
-      start = Time.now
-      prefix = "==#{'=' * parents.size}>"
-      msg = [prefix]
-      msg << "Built a #{name}"
-      msg << "as a dependency of #{parents.last}" if parents.any?
-      msg << "via #{method}"
-
-      yield.tap do
-        msg << "in #{Time.now - start} seconds"
-        puts msg.join(' ')
-        puts if parents.empty?
-      end
-    end
-
-    private_class_method :log_fabrication
-
-    def self.evaluator
-      @evaluator ||= DSL.new(self)
-    end
-
-    private_class_method :evaluator
-
-    class DSL
-      def initialize(base)
-        @base = base
-      end
-
-      def attribute(name, &block)
-        @base.module_eval do
-          attr_writer(name)
-
-          define_method(name) do
-            instance_variable_get("@#{name}") ||
-              instance_variable_set(
-                "@#{name}",
-                populate_attribute(name, block))
-          end
-        end
-      end
-    end
-
-    attribute :web_url
-  end
-end

data/lib/chemlab/runtime/api_client.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'airborne'
-
-module Chemlab
-  module Runtime
-    module API
-      class Client
-        attr_reader :address, :user
-
-        def initialize(address = :gitlab, personal_access_token: nil, is_new_session: true, user: nil, ip_limits: false)
-          @address = address
-          @user = user
-        end
-      end
-    end
-  end
-end

data/lib/chemlab/support/api.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Chemlab
-  module Support
-    module API
-      HTTP_STATUS_OK = 200
-      HTTP_STATUS_CREATED = 201
-      HTTP_STATUS_NO_CONTENT = 204
-      HTTP_STATUS_ACCEPTED = 202
-      HTTP_STATUS_SERVER_ERROR = 500
-
-      def post(url, payload)
-        RestClient::Request.execute(
-          method: :post,
-          url: url,
-          payload: payload,
-          verify_ssl: false)
-      rescue RestClient::ExceptionWithResponse => e
-        return_response_or_raise(e)
-      end
-
-      def get(url, raw_response: false)
-        RestClient::Request.execute(
-          method: :get,
-          url: url,
-          verify_ssl: false,
-          raw_response: raw_response)
-      rescue RestClient::ExceptionWithResponse => e
-        return_response_or_raise(e)
-      end
-
-      def put(url, payload)
-        RestClient::Request.execute(
-          method: :put,
-          url: url,
-          payload: payload,
-          verify_ssl: false)
-      rescue RestClient::ExceptionWithResponse => e
-        return_response_or_raise(e)
-      end
-
-      def delete(url)
-        RestClient::Request.execute(
-          method: :delete,
-          url: url,
-          verify_ssl: false)
-      rescue RestClient::ExceptionWithResponse => e
-        return_response_or_raise(e)
-      end
-
-      def head(url)
-        RestClient::Request.execute(
-          method: :head,
-          url: url,
-          verify_ssl: false)
-      rescue RestClient::ExceptionWithResponse => e
-        return_response_or_raise(e)
-      end
-
-      def parse_body(response)
-        JSON.parse(response.body, symbolize_names: true)
-      end
-
-      def return_response_or_raise(error)
-        raise error unless error.respond_to?(:response) && error.response
-
-        error.response
-      end
-    end
-  end
-end

data/lib/chemlab/support/logging.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-module Chemlab
-  module Support
-    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)
-        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

data/lib/chemlab/support/repeater.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/inflector'
-
-module Chemlab
-  module Support
-    module Repeater
-      DEFAULT_MAX_WAIT_TIME = 60
-
-      RetriesExceededError = Class.new(RuntimeError)
-      WaitExceededError = Class.new(RuntimeError)
-
-      def repeat_until(max_attempts: nil, max_duration: nil, reload_page: nil, sleep_interval: 0, raise_on_failure: true, retry_on_exception: false, log: true)
-        attempts = 0
-        start = Time.now
-
-        begin
-          while remaining_attempts?(attempts, max_attempts) && remaining_time?(start, max_duration)
-            QA::Runtime::Logger.debug("Attempt number #{attempts + 1}") if max_attempts && log
-
-            result = yield
-            return result if result
-
-            sleep_and_reload_if_needed(sleep_interval, reload_page)
-            attempts += 1
-          end
-        rescue StandardError, RSpec::Expectations::ExpectationNotMetError
-          raise unless retry_on_exception
-
-          attempts += 1
-          if remaining_attempts?(attempts, max_attempts) && remaining_time?(start, max_duration)
-            sleep_and_reload_if_needed(sleep_interval, reload_page)
-
-            retry
-          else
-            raise
-          end
-        end
-
-        if raise_on_failure
-          raise RetriesExceededError, "Retry condition not met after #{max_attempts} #{'attempt'.pluralize(max_attempts)}" unless remaining_attempts?(attempts, max_attempts)
-
-          raise WaitExceededError, "Wait condition not met after #{max_duration} #{'second'.pluralize(max_duration)}"
-        end
-
-        false
-      end
-
-      private
-
-      def sleep_and_reload_if_needed(sleep_interval, reload_page)
-        sleep(sleep_interval)
-        reload_page.refresh if reload_page
-      end
-
-      def remaining_attempts?(attempts, max_attempts)
-        max_attempts ? attempts < max_attempts : true
-      end
-
-      def remaining_time?(start, max_duration)
-        max_duration ? Time.now - start < max_duration : true
-      end
-    end
-  end
-end