chemlab 0.0.1 → 0.1.0

data/qa/page/project/wiki/show.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Page
-    module Project
-      module Wiki
-        class Show < Page::Base
-          include Page::Component::LegacyClonePanel
-
-          view 'app/views/projects/wikis/pages.html.haml' do
-            element :clone_repository_link, 'Clone repository' # rubocop:disable QA/ElementWithPattern
-          end
-
-          view 'app/views/projects/wikis/show.html.haml' do
-            element :wiki_page_content
-          end
-
-          def click_clone_repository
-            click_on 'Clone repository'
-          end
-
-          def wiki_text
-            find_element(:wiki_page_content).text
-          end
-        end
-      end
-    end
-  end
-end
-
-QA::Page::Project::Wiki::Show.prepend_if_ee('QA::EE::Page::Project::Wiki::Show')

data/qa/page/search/results.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module QA::Page
-  module Search
-    class Results < QA::Page::Base
-      view 'app/views/search/_category.html.haml' do
-        element :code_tab
-        element :projects_tab
-      end
-
-      view 'app/views/search/results/_blob_data.html.haml' do
-        element :result_item_content
-        element :file_title_content
-        element :file_text_content
-      end
-
-      view 'app/views/shared/projects/_project.html.haml' do
-        element :project
-      end
-
-      def switch_to_code
-        switch_to_tab(:code_tab)
-      end
-
-      def switch_to_projects
-        switch_to_tab(:projects_tab)
-      end
-
-      def has_file_in_project?(file_name, project_name)
-        has_element?(:result_item_content, text: "#{project_name}: #{file_name}")
-      end
-
-      def has_file_with_content?(file_name, file_text)
-        within_element_by_index(:result_item_content, 0) do
-          break false unless has_element?(:file_title_content, text: file_name)
-
-          has_element?(:file_text_content, text: file_text)
-        end
-      end
-
-      def has_project?(project_name)
-        has_element?(:project, project_name: project_name)
-      end
-
-      private
-
-      def switch_to_tab(tab)
-        retry_until do
-          click_element(tab)
-          has_active_element?(tab)
-        end
-      end
-    end
-  end
-end

data/qa/page/settings/common.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Page
-    module Settings
-      module Common
-        # Click the Expand button present in the specified section
-        #
-        # @param [Symbol] element_name `element` name defined in a `view` block
-        def expand_section(element_name)
-          within_element(element_name) do
-            # Because it is possible to click the button before the JS toggle code is bound
-            wait_until(reload: false) do
-              click_button 'Expand' unless has_css?('button', text: 'Collapse', wait: 1)
-
-              has_content?('Collapse')
-              finished_loading?
-            end
-
-            yield if block_given?
-          end
-        end
-      end
-    end
-  end
-end

data/qa/page/sub_menus/common.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Page
-    module SubMenus
-      module Common
-        def hover_element(element)
-          within_sidebar do
-            find_element(element).hover
-            yield
-          end
-        end
-
-        def within_sidebar
-          within_element(sidebar_element) do
-            yield
-          end
-        end
-
-        def within_submenu(element = nil)
-          if element
-            within_element(element) do
-              yield
-            end
-          else
-            within_submenu_without_element do
-              yield
-            end
-          end
-        end
-
-        private
-
-        def within_submenu_without_element
-          if has_css?('.fly-out-list')
-            within('.fly-out-list') do
-              yield
-            end
-          else
-            yield
-          end
-        end
-
-        def sidebar_element
-          raise NotImplementedError
-        end
-      end
-    end
-  end
-end

data/qa/page/validatable.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Page
-    module Validatable
-      PageValidationError = Class.new(StandardError)
-
-      def validate_elements_present!
-        base_page = self.new
-
-        base_page.wait_if_retry_later
-
-        required_elements.each do |element|
-          unless base_page.has_element?(element.name, wait: QA::Support::Repeater::DEFAULT_MAX_WAIT_TIME)
-            raise Validatable::PageValidationError, "#{element.name} did not appear on #{self.name} as expected"
-          end
-        end
-      end
-    end
-  end
-end

data/qa/page/validator.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module QA
-  module Page
-    class Validator
-      ValidationError = Class.new(StandardError)
-
-      Error = Struct.new(:page, :message) do
-        def to_s
-          "Error: #{page} - #{message}"
-        end
-      end
-
-      def initialize(constant)
-        @module = constant
-      end
-
-      def constants
-        @consts ||= @module.constants.map do |const|
-          @module.const_get(const, false)
-        end
-      end
-
-      def descendants
-        @descendants ||= constants.flat_map do |const|
-          case const
-          when Class
-            const if const < Page::Base
-          when Module
-            Page::Validator.new(const).descendants
-          end
-        end.compact
-      end
-
-      def errors
-        [].tap do |errors|
-          descendants.each do |page|
-            page.errors.each do |message|
-              errors.push(Error.new(page.name, message))
-            end
-          end
-        end
-      end
-
-      def validate!
-        return if errors.none?
-
-        raise ValidationError, 'Page views / elements validation error!'
-      end
-    end
-  end
-end

data/qa/page/view.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'pathname'
-
-module QA
-  module Page
-    class View
-      attr_reader :path, :elements
-
-      def initialize(path, elements)
-        @path = path
-        @elements = elements
-      end
-
-      def pathname
-        @pathname ||= ::Pathname.new(::File.join(__dir__, '../../../', @path))
-          .cleanpath.expand_path
-      end
-
-      def errors
-        unless pathname.readable?
-          return ["Missing view partial `#{pathname}`!"]
-        end
-
-        ##
-        # Reduce required elements by streaming view and making assertions on
-        # elements' existence.
-        #
-        @missing ||= @elements.dup.tap do |elements|
-          ::File.foreach(pathname.to_s) do |line|
-            elements.reject! { |element| element.matches?(line) }
-          end
-        end
-
-        @missing.map do |missing|
-          "Missing element `#{missing.name}` in `#{pathname}` view partial!"
-        end
-      end
-
-      def self.evaluate(&block)
-        Page::View::DSL.new.tap do |evaluator|
-          evaluator.instance_exec(&block) if block_given?
-        end
-      end
-
-      class DSL
-        attr_reader :elements
-
-        def initialize
-          @elements = []
-        end
-
-        def element(name, *args)
-          @elements.push(Page::Element.new(name, *args))
-        end
-      end
-    end
-  end
-end

data/qa/resource/api_fabricator.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object/deep_dup'
-require 'capybara/dsl'
-
-module QA
-  module Resource
-    module ApiFabricator
-      include Capybara::DSL
-
-      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
-end

data/qa/resource/base.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'capybara/dsl'
-require 'active_support/core_ext/array/extract_options'
-
-module QA
-  module Resource
-    class Base
-      extend SingleForwardable
-      include ApiFabricator
-      extend Capybara::DSL
-
-      NoValueError = Class.new(RuntimeError)
-
-      def_delegators :evaluator, :attribute
-
-      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
-
-        # Wait until the new page is ready for us to interact with it
-        Support::WaitForRequests.wait_for_requests
-      end
-
-      def populate(*attributes)
-        attributes.each(&method(:public_send))
-      end
-
-      def wait_until(max_duration: 60, sleep_interval: 0.1)
-        QA::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 ||= Base::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
-end