chemlab 0.0.1

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

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

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

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

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

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

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

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

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

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