chemlab 0.4.0 → 0.7.1

data/lib/chemlab/api_fabricator.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object/deep_dup'
-
-module Chemlab
-  # API Fabricator
-  module ApiFabricator
-    ResourceFabricationFailedError = Class.new(RuntimeError)
-    ResourceNotDeletedError = Class.new(RuntimeError)
-    ResourceNotFoundError = Class.new(RuntimeError)
-    ResourceQueryError = Class.new(RuntimeError)
-    ResourceUpdateFailedError = Class.new(RuntimeError)
-    ResourceURLMissingError = Class.new(RuntimeError)
-    InternalServerError = Class.new(RuntimeError)
-
-    attr_reader :api_resource, :api_response
-    attr_writer :api_client
-    attr_accessor :user
-
-    def api_support?
-      respond_to?(:api_get_path) &&
-        (respond_to?(:api_post_path) && respond_to?(:api_post_body)) ||
-        (respond_to?(:api_put_path) && respond_to?(:api_put_body))
-    end
-
-    def fabricate_via_api!
-      unless api_support?
-        raise NotImplementedError, "Resource #{self.class.name} does not support fabrication via the API!"
-      end
-
-      resource_web_url(api_post)
-    end
-
-    def reload!
-      api_get
-
-      self
-    end
-
-    def remove_via_api!
-      api_delete
-    end
-
-    def eager_load_api_client!
-      return unless api_client.nil?
-
-      api_client.tap do |client|
-        # Eager-load the API client so that the personal token creation isn't
-        # taken in account in the actual resource creation timing.
-        client.user = user
-        client.personal_access_token
-      end
-    end
-
-    include Support::API
-
-    attr_writer :api_resource, :api_response
-
-    def api_put(body = api_put_body)
-      response = put(
-        Runtime::API::Request.new(api_client, api_put_path).url,
-        body)
-
-      unless response.code == HTTP_STATUS_OK
-        raise ResourceFabricationFailedError, "Updating #{self.class.name} using the API failed (#{response.code}) with `#{response}`."
-      end
-
-      process_api_response(parse_body(response))
-    end
-
-    private
-
-    def resource_web_url(resource)
-      resource.fetch(:web_url) do
-        raise ResourceURLMissingError, "API resource for #{self.class.name} does not expose a `web_url` property: `#{resource}`."
-      end
-    end
-
-    def api_get
-      process_api_response(parse_body(api_get_from(api_get_path)))
-    end
-
-    def api_get_from(get_path)
-      url = Runtime::API::Request.new(api_client, get_path).url
-      response = get(url)
-
-      if response.code == HTTP_STATUS_SERVER_ERROR
-        raise InternalServerError, "Failed to GET #{url} - (#{response.code}): `#{response}`."
-      elsif response.code != HTTP_STATUS_OK
-        raise ResourceNotFoundError, "Resource at #{url} could not be found (#{response.code}): `#{response}`."
-      end
-
-      response
-    end
-
-    def api_post
-      response = post(
-        Runtime::API::Request.new(api_client, api_post_path).url,
-        api_post_body)
-
-      unless response.code == HTTP_STATUS_CREATED
-        raise ResourceFabricationFailedError, "Fabrication of #{self.class.name} using the API failed (#{response.code}) with `#{response}`."
-      end
-
-      process_api_response(parse_body(response))
-    end
-
-    def api_delete
-      url = Runtime::API::Request.new(api_client, api_delete_path).url
-      response = delete(url)
-
-      unless [HTTP_STATUS_NO_CONTENT, HTTP_STATUS_ACCEPTED].include? response.code
-        raise ResourceNotDeletedError, "Resource at #{url} could not be deleted (#{response.code}): `#{response}`."
-      end
-
-      response
-    end
-
-    def api_client
-      @api_client ||= begin
-                        Runtime::API::Client.new(:gitlab, is_new_session: !current_url.start_with?('http'), user: user)
-                      end
-    end
-
-    def process_api_response(parsed_response)
-      self.api_response = parsed_response
-      self.api_resource = transform_api_resource(parsed_response.deep_dup)
-    end
-
-    def transform_api_resource(api_resource)
-      api_resource
-    end
-  end
-end

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