chemlab 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd40a0ffd6214eeb28234cfef9b4e735f57570cdecddf5e6a0cca422353ed5fc
-  data.tar.gz: 93efdc7b1093ab7226bf268d862bdba9c66fa2764e4165e0d70a49344d9de4ec
+  metadata.gz: f82c920b4402cead6b7bced74d33d7517d6af16df04c93e8b50c852a691c7ead
+  data.tar.gz: 9934077c6073531b4251c3839ff3b02faa736642165039db57039ebdd4849b1c
 SHA512:
-  metadata.gz: bc4380dc722dc70263eea4cd6720a753a98438dc60ee18f2a949e8b74532732b07d458b486601b37ce3a68ed1533ebbbf7f6725637462622caf3464cfc217292
-  data.tar.gz: 5c25a44ad165c00fa36233d5bae6c56adb55e4fb1eec8c713c51deb0e6ed4bfb6207d9e73d776c443d4cf9aae9e132baeb918819e68cea47ec42e60baa782171
+  metadata.gz: 4db0c48669a8f13199bd35760cf890ed76c4d4ff2e83897a062ad14424b4b3960ac7be2dcf055f41643ceb0931eebccea638bfa93789a36659f450129de445e0
+  data.tar.gz: 7c756ff0d2fb485b0a394f07ce84309e08c5a80b5e94854d11523ff1e9ec73ac2f3af2f0570963ad7ec4f2ce609884f0e83b95e56d07462479561c4e1499d3f5

data/lib/chemlab.rb

@@ -1,5 +1,40 @@
 # frozen_string_literal: true
 
+require 'watir'
+
+require 'chemlab/configuration'
+require 'chemlab/attributable'
+require 'chemlab/runtime/env'
+require 'chemlab/runtime/browser'
+require 'chemlab/element'
+require 'chemlab/component'
+require 'chemlab/page'
+require 'chemlab/support/api'
+require 'chemlab/api_fabricator'
+require 'chemlab/resource'
+
+# Chemlaboratory
 module Chemlab
 
+  # Yields the global configuration to a block.
+  # @yield [Configuration] global configuration
+  #
+  # @example
+  #     Chemlab.configure do |config|
+  #       config.base_url = 'https://example.com'
+  #     end
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  # Returns the global [Configuration](Configuration) object. While
+  # you _can_ use this method to access the configuration, the more common
+  # convention is to use Chemlab.configure.
+  #
+  # @example
+  #     Chemlab.configuration.drb_port = 1234
+  # @see Chemlab.configure
+  def self.configuration
+    @configuration ||= Chemlab::Configuration.new
+  end
 end

data/lib/chemlab/api_fabricator.rb

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Chemlab
+  # Attributable module
+  # @example
+  #   class MyClass
+  #     include Attributable
+  #     attribute :url
+  #     attribute :id
+  #     attribute :name { 'test' }
+  module Attributable
+    def attribute(name)
+      default_value = nil
+      default_value = yield if block_given?
+
+      define_method(name) do
+        instance_variable_get("@#{name}") ||
+          instance_variable_set(
+            "@#{name}",
+            default_value
+          )
+      end
+    end
+  end
+end

data/lib/chemlab/component.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Chemlab
+  # The base representation of *any* UI component.
+  class Component
+    extend SingleForwardable
+
+    def_delegator :browser, :browser
+    def_delegators :evaluator, :attribute
+
+    def self.perform
+      yield new if block_given?
+    end
+
+    class << self
+      Watir::Container.instance_methods(false).each do |watir_method|
+        define_method watir_method do |name, *args, &block|
+          next if public_instance_methods.include? name
+
+          define_method("#{name}_element") do
+            find_element(watir_method, name, args.first, &block)
+          end
+
+          define_method("#{name}?") do
+            send("#{name}_element").present?
+          end
+
+          define_method(name) do
+            element = send("#{name}_element")
+            if Element::CLICKABLES.include? watir_method
+              element.wait_until(&:present?).click
+            elsif Element::INPUTS.include? watir_method
+              element.value
+            else
+              element.text
+            end
+          end
+
+          define_method("#{name}=") do |val|
+            if Element::SELECTABLES.include? watir_method
+              send("#{name}_element").select val
+            else
+              send("#{name}_element").set val
+            end
+          end
+        end
+      end
+    end
+
+    class DSL
+      def initialize(base)
+        @base = base
+      end
+
+      def attribute(name)
+        @base.module_eval do
+          attr_writer(name)
+
+          default_value = block_given? ? yield : nil
+
+          define_singleton_method(name) do |value = nil|
+            instance_variable_get("@#{name}") ||
+              instance_variable_set(
+                "@#{name}",
+                value || default_value
+              )
+          end
+        end
+      end
+    end
+
+    def self.evaluator
+      @evaluator ||= DSL.new(self)
+    end
+    private_class_method :evaluator
+
+    private
+
+    def find_element(watir_method, name, locator = nil, &block)
+      locator = { css: %([data-qa-selector="#{name}"]) } if locator.nil?
+
+      return instance_exec(&block) if block_given?
+
+      Chemlab.configuration.browser.session.engine.send(watir_method, locator).wait_until(&:exist?)
+    end
+  end
+end

data/lib/chemlab/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Chemlab
+  # Chemlab Configuration
+  class Configuration
+    # Add a chemlab configuration
+    def self.add_config(name)
+      attr_accessor name
+    end
+
+    add_config :base_url
+
+    attr_reader :browser
+    # Set the browser and browser arguments Chemlab should use
+    def browser=(browser)
+      @browser = Runtime::Browser.new(browser)
+    end
+
+    # Call RSpec.configure for additional configuration
+    def configure_rspec
+      RSpec.configure do |rspec|
+        yield rspec if block_given?
+
+        # TODO Change this. /spec/api /spec/ui is hardcoded
+        rspec.define_derived_metadata(file_path: Regexp.new('/spec/api')) do |metadata|
+          metadata[:type] = :api
+        end
+
+        rspec.define_derived_metadata(file_path: Regexp.new('/spec/ui')) do |metadata|
+          metadata[:type] = :ui
+        end
+
+        rspec.after(:each, type: :ui) do
+          Chemlab.configuration.browser&.session&.engine&.quit
+        end
+      end
+    end
+  end
+end

data/lib/chemlab/element.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Chemlab
+  module Element
+    CLICKABLES = %i[
+      a
+      button
+      link
+      checkbox
+      image
+    ].freeze
+
+    SELECTABLES = %i[
+      select
+    ].freeze
+
+    INPUTS = %i[
+      text_field
+      text_area
+    ].freeze
+  end
+end

data/lib/chemlab/page.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Chemlab
+  # Representation of a Page on the UI
+  class Page < Component
+
+    attribute :url
+
+    def visit
+      Runtime::Browser.navigate_to(self.class)
+    end
+  end
+end

data/lib/chemlab/resource.rb

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